Datasets:

seansullivan

/

Langchain-Docs

like 0

https://python.langchain.com/docs/integrations/vectorstores/hippo/

## Hippo > [Transwarp Hippo](https://www.transwarp.cn/en/subproduct/hippo) is an enterprise-level cloud-native distributed vector database that supports storage, retrieval, and management of massive vector-based datasets. It efficiently solves problems such as vector similarity search and high-density vector clustering. `Hippo` features high availability, high performance, and easy scalability. It has many functions, such as multiple vector search indexes, data partitioning and sharding, data persistence, incremental data ingestion, vector scalar field filtering, and mixed queries. It can effectively meet the high real-time search demands of enterprises for massive vector data ## Getting Started[​](#getting-started "Direct link to Getting Started") The only prerequisite here is an API key from the OpenAI website. Make sure you have already started a Hippo instance. ## Installing Dependencies[​](#installing-dependencies "Direct link to Installing Dependencies") Initially, we require the installation of certain dependencies, such as OpenAI, Langchain, and Hippo-API. Please note, that you should install the appropriate versions tailored to your environment. ``` %pip install --upgrade --quiet langchain tiktoken langchain-openai%pip install --upgrade --quiet hippo-api==1.1.0.rc3 ``` ``` Requirement already satisfied: hippo-api==1.1.0.rc3 in /Users/daochengzhang/miniforge3/envs/py310/lib/python3.10/site-packages (1.1.0rc3)Requirement already satisfied: pyyaml>=6.0 in /Users/daochengzhang/miniforge3/envs/py310/lib/python3.10/site-packages (from hippo-api==1.1.0.rc3) (6.0.1) ``` Note: Python version needs to be \>\=3.8. ## Best Practices[​](#best-practices "Direct link to Best Practices") ### Importing Dependency Packages[​](#importing-dependency-packages "Direct link to Importing Dependency Packages") ``` import osfrom langchain_community.document_loaders import TextLoaderfrom langchain_community.vectorstores.hippo import Hippofrom langchain_openai import ChatOpenAI, OpenAIEmbeddingsfrom langchain_text_splitters import CharacterTextSplitter ``` ### Loading Knowledge Documents[​](#loading-knowledge-documents "Direct link to Loading Knowledge Documents") ``` os.environ["OPENAI_API_KEY"] = "YOUR OPENAI KEY"loader = TextLoader("../../modules/state_of_the_union.txt")documents = loader.load() ``` ### Segmenting the Knowledge Document[​](#segmenting-the-knowledge-document "Direct link to Segmenting the Knowledge Document") Here, we use Langchain’s CharacterTextSplitter for segmentation. The delimiter is a period. After segmentation, the text segment does not exceed 1000 characters, and the number of repeated characters is 0. ``` text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=0)docs = text_splitter.split_documents(documents) ``` ### Declaring the Embedding Model[​](#declaring-the-embedding-model "Direct link to Declaring the Embedding Model") Below, we create the OpenAI or Azure embedding model using the OpenAIEmbeddings method from Langchain. ``` # openaiembeddings = OpenAIEmbeddings()# azure# embeddings = OpenAIEmbeddings(# openai_api_type="azure",# openai_api_base="x x x",# openai_api_version="x x x",# model="x x x",# deployment="x x x",# openai_api_key="x x x"# ) ``` ### Declaring Hippo Client[​](#declaring-hippo-client "Direct link to Declaring Hippo Client") ``` HIPPO_CONNECTION = {"host": "IP", "port": "PORT"} ``` ### Storing the Document[​](#storing-the-document "Direct link to Storing the Document") ``` print("input...")# insert docsvector_store = Hippo.from_documents( docs, embedding=embeddings, table_name="langchain_test", connection_args=HIPPO_CONNECTION,)print("success") ``` ### Conducting Knowledge-based Question and Answer[​](#conducting-knowledge-based-question-and-answer "Direct link to Conducting Knowledge-based Question and Answer") #### Creating a Large Language Question-Answering Model[​](#creating-a-large-language-question-answering-model "Direct link to Creating a Large Language Question-Answering Model") Below, we create the OpenAI or Azure large language question-answering model respectively using the AzureChatOpenAI and ChatOpenAI methods from Langchain. ``` # llm = AzureChatOpenAI(# openai_api_base="x x x",# openai_api_version="xxx",# deployment_name="xxx",# openai_api_key="xxx",# openai_api_type="azure"# )llm = ChatOpenAI(openai_api_key="YOUR OPENAI KEY", model_name="gpt-3.5-turbo-16k") ``` ``` query = "Please introduce COVID-19"# query = "Please introduce Hippo Core Architecture"# query = "What operations does the Hippo Vector Database support for vector data?"# query = "Does Hippo use hardware acceleration technology? Briefly introduce hardware acceleration technology."# Retrieve similar content from the knowledge base,fetch the top two most similar texts.res = vector_store.similarity_search(query, 2)content_list = [item.page_content for item in res]text = "".join(content_list) ``` ### Constructing a Prompt Template[​](#constructing-a-prompt-template "Direct link to Constructing a Prompt Template") ``` prompt = f"""Please use the content of the following [Article] to answer my question. If you don't know, please say you don't know, and the answer should be concise."[Article]:{text}Please answer this question in conjunction with the above article:{query}""" ``` ### Waiting for the Large Language Model to Generate an Answer[​](#waiting-for-the-large-language-model-to-generate-an-answer "Direct link to Waiting for the Large Language Model to Generate an Answer") ``` response_with_hippo = llm.predict(prompt)print(f"response_with_hippo:{response_with_hippo}")response = llm.predict(query)print("==========================================")print(f"response_without_hippo:{response}") ``` ``` response_with_hippo:COVID-19 is a virus that has impacted every aspect of our lives for over two years. It is a highly contagious and mutates easily, requiring us to remain vigilant in combating its spread. However, due to progress made and the resilience of individuals, we are now able to move forward safely and return to more normal routines.==========================================response_without_hippo:COVID-19 is a contagious respiratory illness caused by the novel coronavirus SARS-CoV-2. It was first identified in December 2019 in Wuhan, China and has since spread globally, leading to a pandemic. The virus primarily spreads through respiratory droplets when an infected person coughs, sneezes, talks, or breathes, and can also spread by touching contaminated surfaces and then touching the face. COVID-19 symptoms include fever, cough, shortness of breath, fatigue, muscle or body aches, sore throat, loss of taste or smell, headache, and in severe cases, pneumonia and organ failure. While most people experience mild to moderate symptoms, it can lead to severe illness and even death, particularly among older adults and those with underlying health conditions. To combat the spread of the virus, various preventive measures have been implemented globally, including social distancing, wearing face masks, practicing good hand hygiene, and vaccination efforts. ```

Hippo Transwarp Hippo is an enterprise-level cloud-native distributed vector database that supports storage, retrieval, and management of massive vector-based datasets. It efficiently solves problems such as vector similarity search and high-density vector clustering. Hippo features high availability, high performance, and easy scalability. It has many functions, such as multiple vector search indexes, data partitioning and sharding, data persistence, incremental data ingestion, vector scalar field filtering, and mixed queries. It can effectively meet the high real-time search demands of enterprises for massive vector data Getting Started​ The only prerequisite here is an API key from the OpenAI website. Make sure you have already started a Hippo instance. Installing Dependencies​ Initially, we require the installation of certain dependencies, such as OpenAI, Langchain, and Hippo-API. Please note, that you should install the appropriate versions tailored to your environment. %pip install --upgrade --quiet langchain tiktoken langchain-openai %pip install --upgrade --quiet hippo-api==1.1.0.rc3 Requirement already satisfied: hippo-api==1.1.0.rc3 in /Users/daochengzhang/miniforge3/envs/py310/lib/python3.10/site-packages (1.1.0rc3) Requirement already satisfied: pyyaml>=6.0 in /Users/daochengzhang/miniforge3/envs/py310/lib/python3.10/site-packages (from hippo-api==1.1.0.rc3) (6.0.1) Note: Python version needs to be >=3.8. Best Practices​ Importing Dependency Packages​ import os from langchain_community.document_loaders import TextLoader from langchain_community.vectorstores.hippo import Hippo from langchain_openai import ChatOpenAI, OpenAIEmbeddings from langchain_text_splitters import CharacterTextSplitter Loading Knowledge Documents​ os.environ["OPENAI_API_KEY"] = "YOUR OPENAI KEY" loader = TextLoader("../../modules/state_of_the_union.txt") documents = loader.load() Segmenting the Knowledge Document​ Here, we use Langchain’s CharacterTextSplitter for segmentation. The delimiter is a period. After segmentation, the text segment does not exceed 1000 characters, and the number of repeated characters is 0. text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=0) docs = text_splitter.split_documents(documents) Declaring the Embedding Model​ Below, we create the OpenAI or Azure embedding model using the OpenAIEmbeddings method from Langchain. # openai embeddings = OpenAIEmbeddings() # azure # embeddings = OpenAIEmbeddings( # openai_api_type="azure", # openai_api_base="x x x", # openai_api_version="x x x", # model="x x x", # deployment="x x x", # openai_api_key="x x x" # ) Declaring Hippo Client​ HIPPO_CONNECTION = {"host": "IP", "port": "PORT"} Storing the Document​ print("input...") # insert docs vector_store = Hippo.from_documents( docs, embedding=embeddings, table_name="langchain_test", connection_args=HIPPO_CONNECTION, ) print("success") Conducting Knowledge-based Question and Answer​ Creating a Large Language Question-Answering Model​ Below, we create the OpenAI or Azure large language question-answering model respectively using the AzureChatOpenAI and ChatOpenAI methods from Langchain. # llm = AzureChatOpenAI( # openai_api_base="x x x", # openai_api_version="xxx", # deployment_name="xxx", # openai_api_key="xxx", # openai_api_type="azure" # ) llm = ChatOpenAI(openai_api_key="YOUR OPENAI KEY", model_name="gpt-3.5-turbo-16k") query = "Please introduce COVID-19" # query = "Please introduce Hippo Core Architecture" # query = "What operations does the Hippo Vector Database support for vector data?" # query = "Does Hippo use hardware acceleration technology? Briefly introduce hardware acceleration technology." # Retrieve similar content from the knowledge base,fetch the top two most similar texts. res = vector_store.similarity_search(query, 2) content_list = [item.page_content for item in res] text = "".join(content_list) Constructing a Prompt Template​ prompt = f""" Please use the content of the following [Article] to answer my question. If you don't know, please say you don't know, and the answer should be concise." [Article]:{text} Please answer this question in conjunction with the above article:{query} """ Waiting for the Large Language Model to Generate an Answer​ response_with_hippo = llm.predict(prompt) print(f"response_with_hippo:{response_with_hippo}") response = llm.predict(query) print("==========================================") print(f"response_without_hippo:{response}") response_with_hippo:COVID-19 is a virus that has impacted every aspect of our lives for over two years. It is a highly contagious and mutates easily, requiring us to remain vigilant in combating its spread. However, due to progress made and the resilience of individuals, we are now able to move forward safely and return to more normal routines. ========================================== response_without_hippo:COVID-19 is a contagious respiratory illness caused by the novel coronavirus SARS-CoV-2. It was first identified in December 2019 in Wuhan, China and has since spread globally, leading to a pandemic. The virus primarily spreads through respiratory droplets when an infected person coughs, sneezes, talks, or breathes, and can also spread by touching contaminated surfaces and then touching the face. COVID-19 symptoms include fever, cough, shortness of breath, fatigue, muscle or body aches, sore throat, loss of taste or smell, headache, and in severe cases, pneumonia and organ failure. While most people experience mild to moderate symptoms, it can lead to severe illness and even death, particularly among older adults and those with underlying health conditions. To combat the spread of the virus, various preventive measures have been implemented globally, including social distancing, wearing face masks, practicing good hand hygiene, and vaccination efforts.

https://python.langchain.com/docs/modules/data_connection/document_loaders/csv/

Load CSV data with a single row per document. ``` [Document(page_content='Team: Nationals\n"Payroll (millions)": 81.34\n"Wins": 98', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 0}, lookup_index=0), Document(page_content='Team: Reds\n"Payroll (millions)": 82.20\n"Wins": 97', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 1}, lookup_index=0), Document(page_content='Team: Yankees\n"Payroll (millions)": 197.96\n"Wins": 95', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 2}, lookup_index=0), Document(page_content='Team: Giants\n"Payroll (millions)": 117.62\n"Wins": 94', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 3}, lookup_index=0), Document(page_content='Team: Braves\n"Payroll (millions)": 83.31\n"Wins": 94', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 4}, lookup_index=0), Document(page_content='Team: Athletics\n"Payroll (millions)": 55.37\n"Wins": 94', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 5}, lookup_index=0), Document(page_content='Team: Rangers\n"Payroll (millions)": 120.51\n"Wins": 93', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 6}, lookup_index=0), Document(page_content='Team: Orioles\n"Payroll (millions)": 81.43\n"Wins": 93', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 7}, lookup_index=0), Document(page_content='Team: Rays\n"Payroll (millions)": 64.17\n"Wins": 90', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 8}, lookup_index=0), Document(page_content='Team: Angels\n"Payroll (millions)": 154.49\n"Wins": 89', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 9}, lookup_index=0), Document(page_content='Team: Tigers\n"Payroll (millions)": 132.30\n"Wins": 88', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 10}, lookup_index=0), Document(page_content='Team: Cardinals\n"Payroll (millions)": 110.30\n"Wins": 88', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 11}, lookup_index=0), Document(page_content='Team: Dodgers\n"Payroll (millions)": 95.14\n"Wins": 86', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 12}, lookup_index=0), Document(page_content='Team: White Sox\n"Payroll (millions)": 96.92\n"Wins": 85', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 13}, lookup_index=0), Document(page_content='Team: Brewers\n"Payroll (millions)": 97.65\n"Wins": 83', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 14}, lookup_index=0), Document(page_content='Team: Phillies\n"Payroll (millions)": 174.54\n"Wins": 81', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 15}, lookup_index=0), Document(page_content='Team: Diamondbacks\n"Payroll (millions)": 74.28\n"Wins": 81', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 16}, lookup_index=0), Document(page_content='Team: Pirates\n"Payroll (millions)": 63.43\n"Wins": 79', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 17}, lookup_index=0), Document(page_content='Team: Padres\n"Payroll (millions)": 55.24\n"Wins": 76', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 18}, lookup_index=0), Document(page_content='Team: Mariners\n"Payroll (millions)": 81.97\n"Wins": 75', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 19}, lookup_index=0), Document(page_content='Team: Mets\n"Payroll (millions)": 93.35\n"Wins": 74', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 20}, lookup_index=0), Document(page_content='Team: Blue Jays\n"Payroll (millions)": 75.48\n"Wins": 73', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 21}, lookup_index=0), Document(page_content='Team: Royals\n"Payroll (millions)": 60.91\n"Wins": 72', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 22}, lookup_index=0), Document(page_content='Team: Marlins\n"Payroll (millions)": 118.07\n"Wins": 69', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 23}, lookup_index=0), Document(page_content='Team: Red Sox\n"Payroll (millions)": 173.18\n"Wins": 69', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 24}, lookup_index=0), Document(page_content='Team: Indians\n"Payroll (millions)": 78.43\n"Wins": 68', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 25}, lookup_index=0), Document(page_content='Team: Twins\n"Payroll (millions)": 94.08\n"Wins": 66', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 26}, lookup_index=0), Document(page_content='Team: Rockies\n"Payroll (millions)": 78.06\n"Wins": 64', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 27}, lookup_index=0), Document(page_content='Team: Cubs\n"Payroll (millions)": 88.19\n"Wins": 61', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 28}, lookup_index=0), Document(page_content='Team: Astros\n"Payroll (millions)": 60.65\n"Wins": 55', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 29}, lookup_index=0)] ``` See the [csv module](https://docs.python.org/3/library/csv.html) documentation for more information of what csv args are supported. ``` [Document(page_content='MLB Team: Team\nPayroll in millions: "Payroll (millions)"\nWins: "Wins"', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 0}, lookup_index=0), Document(page_content='MLB Team: Nationals\nPayroll in millions: 81.34\nWins: 98', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 1}, lookup_index=0), Document(page_content='MLB Team: Reds\nPayroll in millions: 82.20\nWins: 97', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 2}, lookup_index=0), Document(page_content='MLB Team: Yankees\nPayroll in millions: 197.96\nWins: 95', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 3}, lookup_index=0), Document(page_content='MLB Team: Giants\nPayroll in millions: 117.62\nWins: 94', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 4}, lookup_index=0), Document(page_content='MLB Team: Braves\nPayroll in millions: 83.31\nWins: 94', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 5}, lookup_index=0), Document(page_content='MLB Team: Athletics\nPayroll in millions: 55.37\nWins: 94', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 6}, lookup_index=0), Document(page_content='MLB Team: Rangers\nPayroll in millions: 120.51\nWins: 93', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 7}, lookup_index=0), Document(page_content='MLB Team: Orioles\nPayroll in millions: 81.43\nWins: 93', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 8}, lookup_index=0), Document(page_content='MLB Team: Rays\nPayroll in millions: 64.17\nWins: 90', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 9}, lookup_index=0), Document(page_content='MLB Team: Angels\nPayroll in millions: 154.49\nWins: 89', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 10}, lookup_index=0), Document(page_content='MLB Team: Tigers\nPayroll in millions: 132.30\nWins: 88', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 11}, lookup_index=0), Document(page_content='MLB Team: Cardinals\nPayroll in millions: 110.30\nWins: 88', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 12}, lookup_index=0), Document(page_content='MLB Team: Dodgers\nPayroll in millions: 95.14\nWins: 86', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 13}, lookup_index=0), Document(page_content='MLB Team: White Sox\nPayroll in millions: 96.92\nWins: 85', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 14}, lookup_index=0), Document(page_content='MLB Team: Brewers\nPayroll in millions: 97.65\nWins: 83', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 15}, lookup_index=0), Document(page_content='MLB Team: Phillies\nPayroll in millions: 174.54\nWins: 81', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 16}, lookup_index=0), Document(page_content='MLB Team: Diamondbacks\nPayroll in millions: 74.28\nWins: 81', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 17}, lookup_index=0), Document(page_content='MLB Team: Pirates\nPayroll in millions: 63.43\nWins: 79', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 18}, lookup_index=0), Document(page_content='MLB Team: Padres\nPayroll in millions: 55.24\nWins: 76', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 19}, lookup_index=0), Document(page_content='MLB Team: Mariners\nPayroll in millions: 81.97\nWins: 75', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 20}, lookup_index=0), Document(page_content='MLB Team: Mets\nPayroll in millions: 93.35\nWins: 74', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 21}, lookup_index=0), Document(page_content='MLB Team: Blue Jays\nPayroll in millions: 75.48\nWins: 73', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 22}, lookup_index=0), Document(page_content='MLB Team: Royals\nPayroll in millions: 60.91\nWins: 72', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 23}, lookup_index=0), Document(page_content='MLB Team: Marlins\nPayroll in millions: 118.07\nWins: 69', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 24}, lookup_index=0), Document(page_content='MLB Team: Red Sox\nPayroll in millions: 173.18\nWins: 69', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 25}, lookup_index=0), Document(page_content='MLB Team: Indians\nPayroll in millions: 78.43\nWins: 68', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 26}, lookup_index=0), Document(page_content='MLB Team: Twins\nPayroll in millions: 94.08\nWins: 66', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 27}, lookup_index=0), Document(page_content='MLB Team: Rockies\nPayroll in millions: 78.06\nWins: 64', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 28}, lookup_index=0), Document(page_content='MLB Team: Cubs\nPayroll in millions: 88.19\nWins: 61', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 29}, lookup_index=0), Document(page_content='MLB Team: Astros\nPayroll in millions: 60.65\nWins: 55', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 30}, lookup_index=0)] ``` Use the `source_column` argument to specify a source for the document created from each row. Otherwise `file_path` will be used as the source for all documents created from the CSV file. This is useful when using documents loaded from CSV files for chains that answer questions using sources. ``` [Document(page_content='Team: Nationals\n"Payroll (millions)": 81.34\n"Wins": 98', lookup_str='', metadata={'source': 'Nationals', 'row': 0}, lookup_index=0), Document(page_content='Team: Reds\n"Payroll (millions)": 82.20\n"Wins": 97', lookup_str='', metadata={'source': 'Reds', 'row': 1}, lookup_index=0), Document(page_content='Team: Yankees\n"Payroll (millions)": 197.96\n"Wins": 95', lookup_str='', metadata={'source': 'Yankees', 'row': 2}, lookup_index=0), Document(page_content='Team: Giants\n"Payroll (millions)": 117.62\n"Wins": 94', lookup_str='', metadata={'source': 'Giants', 'row': 3}, lookup_index=0), Document(page_content='Team: Braves\n"Payroll (millions)": 83.31\n"Wins": 94', lookup_str='', metadata={'source': 'Braves', 'row': 4}, lookup_index=0), Document(page_content='Team: Athletics\n"Payroll (millions)": 55.37\n"Wins": 94', lookup_str='', metadata={'source': 'Athletics', 'row': 5}, lookup_index=0), Document(page_content='Team: Rangers\n"Payroll (millions)": 120.51\n"Wins": 93', lookup_str='', metadata={'source': 'Rangers', 'row': 6}, lookup_index=0), Document(page_content='Team: Orioles\n"Payroll (millions)": 81.43\n"Wins": 93', lookup_str='', metadata={'source': 'Orioles', 'row': 7}, lookup_index=0), Document(page_content='Team: Rays\n"Payroll (millions)": 64.17\n"Wins": 90', lookup_str='', metadata={'source': 'Rays', 'row': 8}, lookup_index=0), Document(page_content='Team: Angels\n"Payroll (millions)": 154.49\n"Wins": 89', lookup_str='', metadata={'source': 'Angels', 'row': 9}, lookup_index=0), Document(page_content='Team: Tigers\n"Payroll (millions)": 132.30\n"Wins": 88', lookup_str='', metadata={'source': 'Tigers', 'row': 10}, lookup_index=0), Document(page_content='Team: Cardinals\n"Payroll (millions)": 110.30\n"Wins": 88', lookup_str='', metadata={'source': 'Cardinals', 'row': 11}, lookup_index=0), Document(page_content='Team: Dodgers\n"Payroll (millions)": 95.14\n"Wins": 86', lookup_str='', metadata={'source': 'Dodgers', 'row': 12}, lookup_index=0), Document(page_content='Team: White Sox\n"Payroll (millions)": 96.92\n"Wins": 85', lookup_str='', metadata={'source': 'White Sox', 'row': 13}, lookup_index=0), Document(page_content='Team: Brewers\n"Payroll (millions)": 97.65\n"Wins": 83', lookup_str='', metadata={'source': 'Brewers', 'row': 14}, lookup_index=0), Document(page_content='Team: Phillies\n"Payroll (millions)": 174.54\n"Wins": 81', lookup_str='', metadata={'source': 'Phillies', 'row': 15}, lookup_index=0), Document(page_content='Team: Diamondbacks\n"Payroll (millions)": 74.28\n"Wins": 81', lookup_str='', metadata={'source': 'Diamondbacks', 'row': 16}, lookup_index=0), Document(page_content='Team: Pirates\n"Payroll (millions)": 63.43\n"Wins": 79', lookup_str='', metadata={'source': 'Pirates', 'row': 17}, lookup_index=0), Document(page_content='Team: Padres\n"Payroll (millions)": 55.24\n"Wins": 76', lookup_str='', metadata={'source': 'Padres', 'row': 18}, lookup_index=0), Document(page_content='Team: Mariners\n"Payroll (millions)": 81.97\n"Wins": 75', lookup_str='', metadata={'source': 'Mariners', 'row': 19}, lookup_index=0), Document(page_content='Team: Mets\n"Payroll (millions)": 93.35\n"Wins": 74', lookup_str='', metadata={'source': 'Mets', 'row': 20}, lookup_index=0), Document(page_content='Team: Blue Jays\n"Payroll (millions)": 75.48\n"Wins": 73', lookup_str='', metadata={'source': 'Blue Jays', 'row': 21}, lookup_index=0), Document(page_content='Team: Royals\n"Payroll (millions)": 60.91\n"Wins": 72', lookup_str='', metadata={'source': 'Royals', 'row': 22}, lookup_index=0), Document(page_content='Team: Marlins\n"Payroll (millions)": 118.07\n"Wins": 69', lookup_str='', metadata={'source': 'Marlins', 'row': 23}, lookup_index=0), Document(page_content='Team: Red Sox\n"Payroll (millions)": 173.18\n"Wins": 69', lookup_str='', metadata={'source': 'Red Sox', 'row': 24}, lookup_index=0), Document(page_content='Team: Indians\n"Payroll (millions)": 78.43\n"Wins": 68', lookup_str='', metadata={'source': 'Indians', 'row': 25}, lookup_index=0), Document(page_content='Team: Twins\n"Payroll (millions)": 94.08\n"Wins": 66', lookup_str='', metadata={'source': 'Twins', 'row': 26}, lookup_index=0), Document(page_content='Team: Rockies\n"Payroll (millions)": 78.06\n"Wins": 64', lookup_str='', metadata={'source': 'Rockies', 'row': 27}, lookup_index=0), Document(page_content='Team: Cubs\n"Payroll (millions)": 88.19\n"Wins": 61', lookup_str='', metadata={'source': 'Cubs', 'row': 28}, lookup_index=0), Document(page_content='Team: Astros\n"Payroll (millions)": 60.65\n"Wins": 55', lookup_str='', metadata={'source': 'Astros', 'row': 29}, lookup_index=0)] ```

Load CSV data with a single row per document. [Document(page_content='Team: Nationals\n"Payroll (millions)": 81.34\n"Wins": 98', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 0}, lookup_index=0), Document(page_content='Team: Reds\n"Payroll (millions)": 82.20\n"Wins": 97', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 1}, lookup_index=0), Document(page_content='Team: Yankees\n"Payroll (millions)": 197.96\n"Wins": 95', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 2}, lookup_index=0), Document(page_content='Team: Giants\n"Payroll (millions)": 117.62\n"Wins": 94', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 3}, lookup_index=0), Document(page_content='Team: Braves\n"Payroll (millions)": 83.31\n"Wins": 94', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 4}, lookup_index=0), Document(page_content='Team: Athletics\n"Payroll (millions)": 55.37\n"Wins": 94', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 5}, lookup_index=0), Document(page_content='Team: Rangers\n"Payroll (millions)": 120.51\n"Wins": 93', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 6}, lookup_index=0), Document(page_content='Team: Orioles\n"Payroll (millions)": 81.43\n"Wins": 93', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 7}, lookup_index=0), Document(page_content='Team: Rays\n"Payroll (millions)": 64.17\n"Wins": 90', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 8}, lookup_index=0), Document(page_content='Team: Angels\n"Payroll (millions)": 154.49\n"Wins": 89', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 9}, lookup_index=0), Document(page_content='Team: Tigers\n"Payroll (millions)": 132.30\n"Wins": 88', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 10}, lookup_index=0), Document(page_content='Team: Cardinals\n"Payroll (millions)": 110.30\n"Wins": 88', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 11}, lookup_index=0), Document(page_content='Team: Dodgers\n"Payroll (millions)": 95.14\n"Wins": 86', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 12}, lookup_index=0), Document(page_content='Team: White Sox\n"Payroll (millions)": 96.92\n"Wins": 85', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 13}, lookup_index=0), Document(page_content='Team: Brewers\n"Payroll (millions)": 97.65\n"Wins": 83', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 14}, lookup_index=0), Document(page_content='Team: Phillies\n"Payroll (millions)": 174.54\n"Wins": 81', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 15}, lookup_index=0), Document(page_content='Team: Diamondbacks\n"Payroll (millions)": 74.28\n"Wins": 81', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 16}, lookup_index=0), Document(page_content='Team: Pirates\n"Payroll (millions)": 63.43\n"Wins": 79', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 17}, lookup_index=0), Document(page_content='Team: Padres\n"Payroll (millions)": 55.24\n"Wins": 76', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 18}, lookup_index=0), Document(page_content='Team: Mariners\n"Payroll (millions)": 81.97\n"Wins": 75', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 19}, lookup_index=0), Document(page_content='Team: Mets\n"Payroll (millions)": 93.35\n"Wins": 74', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 20}, lookup_index=0), Document(page_content='Team: Blue Jays\n"Payroll (millions)": 75.48\n"Wins": 73', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 21}, lookup_index=0), Document(page_content='Team: Royals\n"Payroll (millions)": 60.91\n"Wins": 72', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 22}, lookup_index=0), Document(page_content='Team: Marlins\n"Payroll (millions)": 118.07\n"Wins": 69', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 23}, lookup_index=0), Document(page_content='Team: Red Sox\n"Payroll (millions)": 173.18\n"Wins": 69', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 24}, lookup_index=0), Document(page_content='Team: Indians\n"Payroll (millions)": 78.43\n"Wins": 68', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 25}, lookup_index=0), Document(page_content='Team: Twins\n"Payroll (millions)": 94.08\n"Wins": 66', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 26}, lookup_index=0), Document(page_content='Team: Rockies\n"Payroll (millions)": 78.06\n"Wins": 64', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 27}, lookup_index=0), Document(page_content='Team: Cubs\n"Payroll (millions)": 88.19\n"Wins": 61', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 28}, lookup_index=0), Document(page_content='Team: Astros\n"Payroll (millions)": 60.65\n"Wins": 55', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 29}, lookup_index=0)] See the csv module documentation for more information of what csv args are supported. [Document(page_content='MLB Team: Team\nPayroll in millions: "Payroll (millions)"\nWins: "Wins"', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 0}, lookup_index=0), Document(page_content='MLB Team: Nationals\nPayroll in millions: 81.34\nWins: 98', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 1}, lookup_index=0), Document(page_content='MLB Team: Reds\nPayroll in millions: 82.20\nWins: 97', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 2}, lookup_index=0), Document(page_content='MLB Team: Yankees\nPayroll in millions: 197.96\nWins: 95', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 3}, lookup_index=0), Document(page_content='MLB Team: Giants\nPayroll in millions: 117.62\nWins: 94', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 4}, lookup_index=0), Document(page_content='MLB Team: Braves\nPayroll in millions: 83.31\nWins: 94', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 5}, lookup_index=0), Document(page_content='MLB Team: Athletics\nPayroll in millions: 55.37\nWins: 94', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 6}, lookup_index=0), Document(page_content='MLB Team: Rangers\nPayroll in millions: 120.51\nWins: 93', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 7}, lookup_index=0), Document(page_content='MLB Team: Orioles\nPayroll in millions: 81.43\nWins: 93', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 8}, lookup_index=0), Document(page_content='MLB Team: Rays\nPayroll in millions: 64.17\nWins: 90', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 9}, lookup_index=0), Document(page_content='MLB Team: Angels\nPayroll in millions: 154.49\nWins: 89', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 10}, lookup_index=0), Document(page_content='MLB Team: Tigers\nPayroll in millions: 132.30\nWins: 88', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 11}, lookup_index=0), Document(page_content='MLB Team: Cardinals\nPayroll in millions: 110.30\nWins: 88', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 12}, lookup_index=0), Document(page_content='MLB Team: Dodgers\nPayroll in millions: 95.14\nWins: 86', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 13}, lookup_index=0), Document(page_content='MLB Team: White Sox\nPayroll in millions: 96.92\nWins: 85', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 14}, lookup_index=0), Document(page_content='MLB Team: Brewers\nPayroll in millions: 97.65\nWins: 83', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 15}, lookup_index=0), Document(page_content='MLB Team: Phillies\nPayroll in millions: 174.54\nWins: 81', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 16}, lookup_index=0), Document(page_content='MLB Team: Diamondbacks\nPayroll in millions: 74.28\nWins: 81', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 17}, lookup_index=0), Document(page_content='MLB Team: Pirates\nPayroll in millions: 63.43\nWins: 79', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 18}, lookup_index=0), Document(page_content='MLB Team: Padres\nPayroll in millions: 55.24\nWins: 76', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 19}, lookup_index=0), Document(page_content='MLB Team: Mariners\nPayroll in millions: 81.97\nWins: 75', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 20}, lookup_index=0), Document(page_content='MLB Team: Mets\nPayroll in millions: 93.35\nWins: 74', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 21}, lookup_index=0), Document(page_content='MLB Team: Blue Jays\nPayroll in millions: 75.48\nWins: 73', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 22}, lookup_index=0), Document(page_content='MLB Team: Royals\nPayroll in millions: 60.91\nWins: 72', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 23}, lookup_index=0), Document(page_content='MLB Team: Marlins\nPayroll in millions: 118.07\nWins: 69', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 24}, lookup_index=0), Document(page_content='MLB Team: Red Sox\nPayroll in millions: 173.18\nWins: 69', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 25}, lookup_index=0), Document(page_content='MLB Team: Indians\nPayroll in millions: 78.43\nWins: 68', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 26}, lookup_index=0), Document(page_content='MLB Team: Twins\nPayroll in millions: 94.08\nWins: 66', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 27}, lookup_index=0), Document(page_content='MLB Team: Rockies\nPayroll in millions: 78.06\nWins: 64', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 28}, lookup_index=0), Document(page_content='MLB Team: Cubs\nPayroll in millions: 88.19\nWins: 61', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 29}, lookup_index=0), Document(page_content='MLB Team: Astros\nPayroll in millions: 60.65\nWins: 55', lookup_str='', metadata={'source': './example_data/mlb_teams_2012.csv', 'row': 30}, lookup_index=0)] Use the source_column argument to specify a source for the document created from each row. Otherwise file_path will be used as the source for all documents created from the CSV file. This is useful when using documents loaded from CSV files for chains that answer questions using sources. [Document(page_content='Team: Nationals\n"Payroll (millions)": 81.34\n"Wins": 98', lookup_str='', metadata={'source': 'Nationals', 'row': 0}, lookup_index=0), Document(page_content='Team: Reds\n"Payroll (millions)": 82.20\n"Wins": 97', lookup_str='', metadata={'source': 'Reds', 'row': 1}, lookup_index=0), Document(page_content='Team: Yankees\n"Payroll (millions)": 197.96\n"Wins": 95', lookup_str='', metadata={'source': 'Yankees', 'row': 2}, lookup_index=0), Document(page_content='Team: Giants\n"Payroll (millions)": 117.62\n"Wins": 94', lookup_str='', metadata={'source': 'Giants', 'row': 3}, lookup_index=0), Document(page_content='Team: Braves\n"Payroll (millions)": 83.31\n"Wins": 94', lookup_str='', metadata={'source': 'Braves', 'row': 4}, lookup_index=0), Document(page_content='Team: Athletics\n"Payroll (millions)": 55.37\n"Wins": 94', lookup_str='', metadata={'source': 'Athletics', 'row': 5}, lookup_index=0), Document(page_content='Team: Rangers\n"Payroll (millions)": 120.51\n"Wins": 93', lookup_str='', metadata={'source': 'Rangers', 'row': 6}, lookup_index=0), Document(page_content='Team: Orioles\n"Payroll (millions)": 81.43\n"Wins": 93', lookup_str='', metadata={'source': 'Orioles', 'row': 7}, lookup_index=0), Document(page_content='Team: Rays\n"Payroll (millions)": 64.17\n"Wins": 90', lookup_str='', metadata={'source': 'Rays', 'row': 8}, lookup_index=0), Document(page_content='Team: Angels\n"Payroll (millions)": 154.49\n"Wins": 89', lookup_str='', metadata={'source': 'Angels', 'row': 9}, lookup_index=0), Document(page_content='Team: Tigers\n"Payroll (millions)": 132.30\n"Wins": 88', lookup_str='', metadata={'source': 'Tigers', 'row': 10}, lookup_index=0), Document(page_content='Team: Cardinals\n"Payroll (millions)": 110.30\n"Wins": 88', lookup_str='', metadata={'source': 'Cardinals', 'row': 11}, lookup_index=0), Document(page_content='Team: Dodgers\n"Payroll (millions)": 95.14\n"Wins": 86', lookup_str='', metadata={'source': 'Dodgers', 'row': 12}, lookup_index=0), Document(page_content='Team: White Sox\n"Payroll (millions)": 96.92\n"Wins": 85', lookup_str='', metadata={'source': 'White Sox', 'row': 13}, lookup_index=0), Document(page_content='Team: Brewers\n"Payroll (millions)": 97.65\n"Wins": 83', lookup_str='', metadata={'source': 'Brewers', 'row': 14}, lookup_index=0), Document(page_content='Team: Phillies\n"Payroll (millions)": 174.54\n"Wins": 81', lookup_str='', metadata={'source': 'Phillies', 'row': 15}, lookup_index=0), Document(page_content='Team: Diamondbacks\n"Payroll (millions)": 74.28\n"Wins": 81', lookup_str='', metadata={'source': 'Diamondbacks', 'row': 16}, lookup_index=0), Document(page_content='Team: Pirates\n"Payroll (millions)": 63.43\n"Wins": 79', lookup_str='', metadata={'source': 'Pirates', 'row': 17}, lookup_index=0), Document(page_content='Team: Padres\n"Payroll (millions)": 55.24\n"Wins": 76', lookup_str='', metadata={'source': 'Padres', 'row': 18}, lookup_index=0), Document(page_content='Team: Mariners\n"Payroll (millions)": 81.97\n"Wins": 75', lookup_str='', metadata={'source': 'Mariners', 'row': 19}, lookup_index=0), Document(page_content='Team: Mets\n"Payroll (millions)": 93.35\n"Wins": 74', lookup_str='', metadata={'source': 'Mets', 'row': 20}, lookup_index=0), Document(page_content='Team: Blue Jays\n"Payroll (millions)": 75.48\n"Wins": 73', lookup_str='', metadata={'source': 'Blue Jays', 'row': 21}, lookup_index=0), Document(page_content='Team: Royals\n"Payroll (millions)": 60.91\n"Wins": 72', lookup_str='', metadata={'source': 'Royals', 'row': 22}, lookup_index=0), Document(page_content='Team: Marlins\n"Payroll (millions)": 118.07\n"Wins": 69', lookup_str='', metadata={'source': 'Marlins', 'row': 23}, lookup_index=0), Document(page_content='Team: Red Sox\n"Payroll (millions)": 173.18\n"Wins": 69', lookup_str='', metadata={'source': 'Red Sox', 'row': 24}, lookup_index=0), Document(page_content='Team: Indians\n"Payroll (millions)": 78.43\n"Wins": 68', lookup_str='', metadata={'source': 'Indians', 'row': 25}, lookup_index=0), Document(page_content='Team: Twins\n"Payroll (millions)": 94.08\n"Wins": 66', lookup_str='', metadata={'source': 'Twins', 'row': 26}, lookup_index=0), Document(page_content='Team: Rockies\n"Payroll (millions)": 78.06\n"Wins": 64', lookup_str='', metadata={'source': 'Rockies', 'row': 27}, lookup_index=0), Document(page_content='Team: Cubs\n"Payroll (millions)": 88.19\n"Wins": 61', lookup_str='', metadata={'source': 'Cubs', 'row': 28}, lookup_index=0), Document(page_content='Team: Astros\n"Payroll (millions)": 60.65\n"Wins": 55', lookup_str='', metadata={'source': 'Astros', 'row': 29}, lookup_index=0)]

https://python.langchain.com/docs/modules/agents/agent_types/openai_tools/

## OpenAI tools Newer OpenAI models have been fine-tuned to detect when **one or more** function(s) should be called and respond with the inputs that should be passed to the function(s). In an API call, you can describe functions and have the model intelligently choose to output a JSON object containing arguments to call these functions. The goal of the OpenAI tools APIs is to more reliably return valid and useful function calls than what can be done using a generic text completion or chat API. OpenAI termed the capability to invoke a **single** function as **functions**, and the capability to invoke **one or more** functions as **tools**. tip In the OpenAI Chat API, **functions** are now considered a legacy options that is deprecated in favor of **tools**. If you’re creating agents using OpenAI models, you should be using this OpenAI Tools agent rather than the OpenAI functions agent. Using **tools** allows the model to request that more than one function will be called upon when appropriate. In some situations, this can help signficantly reduce the time that it takes an agent to achieve its goal. See * [OpenAI chat create](https://platform.openai.com/docs/api-reference/chat/create) * [OpenAI function calling](https://platform.openai.com/docs/guides/function-calling) ``` %pip install --upgrade --quiet langchain-openai tavily-python ``` ``` from langchain import hubfrom langchain.agents import AgentExecutor, create_openai_tools_agentfrom langchain_community.tools.tavily_search import TavilySearchResultsfrom langchain_openai import ChatOpenAI ``` For this agent let’s give it the ability to search the web with Tavily. ``` tools = [TavilySearchResults(max_results=1)] ``` ## Create Agent[​](#create-agent "Direct link to Create Agent") ``` # Get the prompt to use - you can modify this!prompt = hub.pull("hwchase17/openai-tools-agent") ``` ``` # Choose the LLM that will drive the agent# Only certain models support thisllm = ChatOpenAI(model="gpt-3.5-turbo-1106", temperature=0)# Construct the OpenAI Tools agentagent = create_openai_tools_agent(llm, tools, prompt) ``` ## Run Agent[​](#run-agent "Direct link to Run Agent") ``` # Create an agent executor by passing in the agent and toolsagent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) ``` ``` agent_executor.invoke({"input": "what is LangChain?"}) ``` ``` > Entering new AgentExecutor chain...Invoking: `tavily_search_results_json` with `{'query': 'LangChain'}`[{'url': 'https://www.ibm.com/topics/langchain', 'content': 'LangChain is essentially a library of abstractions for Python and Javascript, representing common steps and concepts LangChain is an open source orchestration framework for the development of applications using large language models other LangChain features, like the eponymous chains. LangChain provides integrations for over 25 different embedding methods, as well as for over 50 different vector storesLangChain is a tool for building applications using large language models (LLMs) like chatbots and virtual agents. It simplifies the process of programming and integration with external data sources and software workflows. It supports Python and Javascript languages and supports various LLM providers, including OpenAI, Google, and IBM.'}]LangChain is an open source orchestration framework for the development of applications using large language models. It is essentially a library of abstractions for Python and Javascript, representing common steps and concepts. LangChain simplifies the process of programming and integration with external data sources and software workflows. It supports various large language model providers, including OpenAI, Google, and IBM. You can find more information about LangChain on the IBM website: [LangChain - IBM](https://www.ibm.com/topics/langchain)> Finished chain. ``` ``` {'input': 'what is LangChain?', 'output': 'LangChain is an open source orchestration framework for the development of applications using large language models. It is essentially a library of abstractions for Python and Javascript, representing common steps and concepts. LangChain simplifies the process of programming and integration with external data sources and software workflows. It supports various large language model providers, including OpenAI, Google, and IBM. You can find more information about LangChain on the IBM website: [LangChain - IBM](https://www.ibm.com/topics/langchain)'} ``` ## Using with chat history[​](#using-with-chat-history "Direct link to Using with chat history") ``` from langchain_core.messages import AIMessage, HumanMessageagent_executor.invoke( { "input": "what's my name? Don't use tools to look this up unless you NEED to", "chat_history": [ HumanMessage(content="hi! my name is bob"), AIMessage(content="Hello Bob! How can I assist you today?"), ], }) ``` ``` > Entering new AgentExecutor chain...Your name is Bob.> Finished chain. ``` ``` {'input': "what's my name? Don't use tools to look this up unless you NEED to", 'chat_history': [HumanMessage(content='hi! my name is bob'), AIMessage(content='Hello Bob! How can I assist you today?')], 'output': 'Your name is Bob.'} ```

OpenAI tools Newer OpenAI models have been fine-tuned to detect when one or more function(s) should be called and respond with the inputs that should be passed to the function(s). In an API call, you can describe functions and have the model intelligently choose to output a JSON object containing arguments to call these functions. The goal of the OpenAI tools APIs is to more reliably return valid and useful function calls than what can be done using a generic text completion or chat API. OpenAI termed the capability to invoke a single function as functions, and the capability to invoke one or more functions as tools. tip In the OpenAI Chat API, functions are now considered a legacy options that is deprecated in favor of tools. If you’re creating agents using OpenAI models, you should be using this OpenAI Tools agent rather than the OpenAI functions agent. Using tools allows the model to request that more than one function will be called upon when appropriate. In some situations, this can help signficantly reduce the time that it takes an agent to achieve its goal. See OpenAI chat create OpenAI function calling %pip install --upgrade --quiet langchain-openai tavily-python from langchain import hub from langchain.agents import AgentExecutor, create_openai_tools_agent from langchain_community.tools.tavily_search import TavilySearchResults from langchain_openai import ChatOpenAI For this agent let’s give it the ability to search the web with Tavily. tools = [TavilySearchResults(max_results=1)] Create Agent​ # Get the prompt to use - you can modify this! prompt = hub.pull("hwchase17/openai-tools-agent") # Choose the LLM that will drive the agent # Only certain models support this llm = ChatOpenAI(model="gpt-3.5-turbo-1106", temperature=0) # Construct the OpenAI Tools agent agent = create_openai_tools_agent(llm, tools, prompt) Run Agent​ # Create an agent executor by passing in the agent and tools agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) agent_executor.invoke({"input": "what is LangChain?"}) > Entering new AgentExecutor chain... Invoking: `tavily_search_results_json` with `{'query': 'LangChain'}` [{'url': 'https://www.ibm.com/topics/langchain', 'content': 'LangChain is essentially a library of abstractions for Python and Javascript, representing common steps and concepts LangChain is an open source orchestration framework for the development of applications using large language models other LangChain features, like the eponymous chains. LangChain provides integrations for over 25 different embedding methods, as well as for over 50 different vector storesLangChain is a tool for building applications using large language models (LLMs) like chatbots and virtual agents. It simplifies the process of programming and integration with external data sources and software workflows. It supports Python and Javascript languages and supports various LLM providers, including OpenAI, Google, and IBM.'}]LangChain is an open source orchestration framework for the development of applications using large language models. It is essentially a library of abstractions for Python and Javascript, representing common steps and concepts. LangChain simplifies the process of programming and integration with external data sources and software workflows. It supports various large language model providers, including OpenAI, Google, and IBM. You can find more information about LangChain on the IBM website: [LangChain - IBM](https://www.ibm.com/topics/langchain) > Finished chain. {'input': 'what is LangChain?', 'output': 'LangChain is an open source orchestration framework for the development of applications using large language models. It is essentially a library of abstractions for Python and Javascript, representing common steps and concepts. LangChain simplifies the process of programming and integration with external data sources and software workflows. It supports various large language model providers, including OpenAI, Google, and IBM. You can find more information about LangChain on the IBM website: [LangChain - IBM](https://www.ibm.com/topics/langchain)'} Using with chat history​ from langchain_core.messages import AIMessage, HumanMessage agent_executor.invoke( { "input": "what's my name? Don't use tools to look this up unless you NEED to", "chat_history": [ HumanMessage(content="hi! my name is bob"), AIMessage(content="Hello Bob! How can I assist you today?"), ], } ) > Entering new AgentExecutor chain... Your name is Bob. > Finished chain. {'input': "what's my name? Don't use tools to look this up unless you NEED to", 'chat_history': [HumanMessage(content='hi! my name is bob'), AIMessage(content='Hello Bob! How can I assist you today?')], 'output': 'Your name is Bob.'}

https://python.langchain.com/docs/integrations/vectorstores/google_vertex_ai_vector_search/

This notebook shows how to use functionality related to the `Google Cloud Vertex AI Vector Search` vector database. > [Google Vertex AI Vector Search](https://cloud.google.com/vertex-ai/docs/vector-search/overview), formerly known as Vertex AI Matching Engine, provides the industry’s leading high-scale low latency vector database. These vector databases are commonly referred to as vector similarity-matching or an approximate nearest neighbor (ANN) service. **Note**: Langchain API expects an endpoint and deployed index already created.Index creation time can take upto one hour. > To see how to create an index refer to the section [Create Index and deploy it to an Endpoint](#create-index-and-deploy-it-to-an-endpoint) > If you already have an index deployed , skip to [Create VectorStore from texts](#create-vector-store-from-texts) ## Create Index and deploy it to an Endpoint[​](#create-index-and-deploy-it-to-an-endpoint "Direct link to Create Index and deploy it to an Endpoint") * This section demonstrates creating a new index and deploying it to an endpoint ``` # TODO : Set values as per your requirements# Project and Storage ConstantsPROJECT_ID = "<my_project_id>"REGION = "<my_region>"BUCKET = "<my_gcs_bucket>"BUCKET_URI = f"gs://{BUCKET}"# The number of dimensions for the textembedding-gecko@003 is 768# If other embedder is used, the dimensions would probably need to change.DIMENSIONS = 768# Index ConstantsDISPLAY_NAME = "<my_matching_engine_index_id>"DEPLOYED_INDEX_ID = "<my_matching_engine_endpoint_id>" ``` ``` # Create a bucket.! gsutil mb -l $REGION -p $PROJECT_ID $BUCKET_URI ``` ### Use [VertexAIEmbeddings](https://python.langchain.com/docs/integrations/text_embedding/google_vertex_ai_palm/) as the embeddings model[​](#use-vertexaiembeddings-as-the-embeddings-model "Direct link to use-vertexaiembeddings-as-the-embeddings-model") ``` from google.cloud import aiplatformfrom langchain_google_vertexai import VertexAIEmbeddings ``` ``` aiplatform.init(project=PROJECT_ID, location=REGION, staging_bucket=BUCKET_URI) ``` ``` embedding_model = VertexAIEmbeddings(model_name="textembedding-gecko@003") ``` ### Create an empty Index[​](#create-an-empty-index "Direct link to Create an empty Index") **Note :** While creating an index you should specify an “index\_update\_method” from either a “BATCH\_UPDATE” or “STREAM\_UPDATE” \> A batch index is for when you want to update your index in a batch, with data which has been stored over a set amount of time, like systems which are processed weekly or monthly. A streaming index is when you want index data to be updated as new data is added to your datastore, for instance, if you have a bookstore and want to show new inventory online as soon as possible. Which type you choose is important, since setup and requirements are different. Refer [Official Documentation](https://cloud.google.com/vertex-ai/docs/vector-search/create-manage-index#create-index-batch) for more details on configuring indexes ``` # NOTE : This operation can take upto 30 secondsmy_index = aiplatform.MatchingEngineIndex.create_tree_ah_index( display_name=DISPLAY_NAME, dimensions=DIMENSIONS, approximate_neighbors_count=150, distance_measure_type="DOT_PRODUCT_DISTANCE", index_update_method="STREAM_UPDATE", # allowed values BATCH_UPDATE , STREAM_UPDATE) ``` ### Create an Endpoint[​](#create-an-endpoint "Direct link to Create an Endpoint") ``` # Create an endpointmy_index_endpoint = aiplatform.MatchingEngineIndexEndpoint.create( display_name=f"{DISPLAY_NAME}-endpoint", public_endpoint_enabled=True) ``` ### Deploy Index to the Endpoint[​](#deploy-index-to-the-endpoint "Direct link to Deploy Index to the Endpoint") ``` # NOTE : This operation can take upto 20 minutesmy_index_endpoint = my_index_endpoint.deploy_index( index=my_index, deployed_index_id=DEPLOYED_INDEX_ID)my_index_endpoint.deployed_indexes ``` ## Create Vector Store from texts[​](#create-vector-store-from-texts "Direct link to Create Vector Store from texts") ``` from langchain_google_vertexai import ( VectorSearchVectorStore, VectorSearchVectorStoreDatastore,) ```  ### Create simple vectorstore ( without filters)[​](#create-simple-vectorstore-without-filters "Direct link to Create simple vectorstore ( without filters)") ``` # Input textstexts = [ "The cat sat on", "the mat.", "I like to", "eat pizza for", "dinner.", "The sun sets", "in the west.",]# Create a Vector Storevector_store = VectorSearchVectorStore.from_components( project_id=PROJECT_ID, region=REGION, gcs_bucket_name=BUCKET, index_id=my_index.name, endpoint_id=my_index_endpoint.name, embedding=embedding_model, stream_update=True,)# Add vectors and mapped text chunks to your vectore storevector_store.add_texts(texts=texts) ``` ### OPTIONAL : You can also create vectore and store chunks in a Datastore[​](#optional-you-can-also-create-vectore-and-store-chunks-in-a-datastore "Direct link to OPTIONAL : You can also create vectore and store chunks in a Datastore") ``` # NOTE : This operation can take upto 20 minsvector_store = VectorSearchVectorStoreDatastore.from_components( project_id=PROJECT_ID, region=REGION, index_id=my_index.name, endpoint_id=my_index_endpoint.name, embedding=embedding_model, stream_update=True,)vector_store.add_texts(texts=texts, is_complete_overwrite=True) ``` ``` # Try running a simialarity searchvector_store.similarity_search("pizza") ``` ### Create vectorstore with metadata filters[​](#create-vectorstore-with-metadata-filters "Direct link to Create vectorstore with metadata filters") ``` # Input text with metadatarecord_data = [ { "description": "A versatile pair of dark-wash denim jeans." "Made from durable cotton with a classic straight-leg cut, these jeans" " transition easily from casual days to dressier occasions.", "price": 65.00, "color": "blue", "season": ["fall", "winter", "spring"], }, { "description": "A lightweight linen button-down shirt in a crisp white." " Perfect for keeping cool with breathable fabric and a relaxed fit.", "price": 34.99, "color": "white", "season": ["summer", "spring"], }, { "description": "A soft, chunky knit sweater in a vibrant forest green. " "The oversized fit and cozy wool blend make this ideal for staying warm " "when the temperature drops.", "price": 89.99, "color": "green", "season": ["fall", "winter"], }, { "description": "A classic crewneck t-shirt in a soft, heathered blue. " "Made from comfortable cotton jersey, this t-shirt is a wardrobe essential " "that works for every season.", "price": 19.99, "color": "blue", "season": ["fall", "winter", "summer", "spring"], }, { "description": "A flowing midi-skirt in a delicate floral print. " "Lightweight and airy, this skirt adds a touch of feminine style " "to warmer days.", "price": 45.00, "color": "white", "season": ["spring", "summer"], },] ``` ``` # Parse and prepare input datatexts = []metadatas = []for record in record_data: record = record.copy() page_content = record.pop("description") texts.append(page_content) if isinstance(page_content, str): metadata = {**record} metadatas.append(metadata) ``` ``` # Inspect metadatasmetadatas ``` ``` # NOTE : This operation can take more than 20 minsvector_store = VectorSearchVectorStore.from_components( project_id=PROJECT_ID, region=REGION, gcs_bucket_name=BUCKET, index_id=my_index.name, endpoint_id=my_index_endpoint.name, embedding=embedding_model,)vector_store.add_texts(texts=texts, metadatas=metadatas, is_complete_overwrite=True) ``` ``` from google.cloud.aiplatform.matching_engine.matching_engine_index_endpoint import ( Namespace, NumericNamespace,) ``` ``` # Try running a simple similarity search# Below code should return 5 resultsvector_store.similarity_search("shirt", k=5) ``` ``` # Try running a similarity search with text filterfilters = [Namespace(name="season", allow_tokens=["spring"])]# Below code should return 4 results nowvector_store.similarity_search("shirt", k=5, filter=filters) ``` ``` # Try running a similarity search with combination of text and numeric filterfilters = [Namespace(name="season", allow_tokens=["spring"])]numeric_filters = [NumericNamespace(name="price", value_float=40.0, op="LESS")]# Below code should return 2 results nowvector_store.similarity_search( "shirt", k=5, filter=filters, numeric_filter=numeric_filters) ``` ### Use Vector Store as retriever[​](#use-vector-store-as-retriever "Direct link to Use Vector Store as retriever") ``` # Initialize the vectore_store as retrieverretriever = vector_store.as_retriever() ``` ``` # perform simple similarity search on retrieverretriever.get_relevant_documents("What are my options in breathable fabric?") ``` ``` # Try running a similarity search with text filterfilters = [Namespace(name="season", allow_tokens=["spring"])]retriever.search_kwargs = {"filter": filters}# perform similarity search with filters on retrieverretriever.get_relevant_documents("What are my options in breathable fabric?") ``` ``` # Try running a similarity search with combination of text and numeric filterfilters = [Namespace(name="season", allow_tokens=["spring"])]numeric_filters = [NumericNamespace(name="price", value_float=40.0, op="LESS")]retriever.search_kwargs = {"filter": filters, "numeric_filter": numeric_filters}retriever.get_relevant_documents("What are my options in breathable fabric?") ``` ### Use filters with retriever in Question Answering Chains[​](#use-filters-with-retriever-in-question-answering-chains "Direct link to Use filters with retriever in Question Answering Chains") ``` from langchain_google_vertexai import VertexAIllm = VertexAI(model_name="gemini-pro") ``` ``` from langchain.chains import RetrievalQAfilters = [Namespace(name="season", allow_tokens=["spring"])]numeric_filters = [NumericNamespace(name="price", value_float=40.0, op="LESS")]retriever.search_kwargs = {"k": 2, "filter": filters, "numeric_filter": numeric_filters}retrieval_qa = RetrievalQA.from_chain_type( llm=llm, chain_type="stuff", retriever=retriever, return_source_documents=True,)question = "What are my options in breathable fabric?"response = retrieval_qa({"query": question})print(f"{response['result']}")print("REFERENCES")print(f"{response['source_documents']}") ``` ## Read , Chunk , Vectorise and Index PDFs[​](#read-chunk-vectorise-and-index-pdfs "Direct link to Read , Chunk , Vectorise and Index PDFs") ``` from langchain_community.document_loaders import PyPDFLoaderfrom langchain_text_splitters import RecursiveCharacterTextSplitter ``` ``` loader = PyPDFLoader("https://arxiv.org/pdf/1706.03762.pdf")pages = loader.load() ``` ``` text_splitter = RecursiveCharacterTextSplitter( # Set a really small chunk size, just to show. chunk_size=1000, chunk_overlap=20, length_function=len, is_separator_regex=False,)doc_splits = text_splitter.split_documents(pages) ``` ``` texts = [doc.page_content for doc in doc_splits]metadatas = [doc.metadata for doc in doc_splits] ``` ``` # Inspect Metadata of 1st pagemetadatas[0] ``` ``` vector_store = VectorSearchVectorStore.from_components( project_id=PROJECT_ID, region=REGION, gcs_bucket_name=BUCKET, index_id=my_index.name, endpoint_id=my_index_endpoint.name, embedding=embedding_model,)vector_store.add_texts(texts=texts, metadatas=metadatas, is_complete_overwrite=True) ``` ``` my_index = aiplatform.MatchingEngineIndex("5908955807575179264")my_index_endpoint = aiplatform.MatchingEngineIndexEndpoint("7751631742611488768") ``` ``` vector_store = VectorSearchVectorStore.from_components( project_id=PROJECT_ID, region=REGION, gcs_bucket_name=BUCKET, index_id=my_index.name, endpoint_id=my_index_endpoint.name, embedding=embedding_model,) ```

This notebook shows how to use functionality related to the Google Cloud Vertex AI Vector Search vector database. Google Vertex AI Vector Search, formerly known as Vertex AI Matching Engine, provides the industry’s leading high-scale low latency vector database. These vector databases are commonly referred to as vector similarity-matching or an approximate nearest neighbor (ANN) service. Note: Langchain API expects an endpoint and deployed index already created.Index creation time can take upto one hour. To see how to create an index refer to the section Create Index and deploy it to an Endpoint If you already have an index deployed , skip to Create VectorStore from texts Create Index and deploy it to an Endpoint​ This section demonstrates creating a new index and deploying it to an endpoint # TODO : Set values as per your requirements # Project and Storage Constants PROJECT_ID = "<my_project_id>" REGION = "<my_region>" BUCKET = "<my_gcs_bucket>" BUCKET_URI = f"gs://{BUCKET}" # The number of dimensions for the textembedding-gecko@003 is 768 # If other embedder is used, the dimensions would probably need to change. DIMENSIONS = 768 # Index Constants DISPLAY_NAME = "<my_matching_engine_index_id>" DEPLOYED_INDEX_ID = "<my_matching_engine_endpoint_id>" # Create a bucket. ! gsutil mb -l $REGION -p $PROJECT_ID $BUCKET_URI Use VertexAIEmbeddings as the embeddings model​ from google.cloud import aiplatform from langchain_google_vertexai import VertexAIEmbeddings aiplatform.init(project=PROJECT_ID, location=REGION, staging_bucket=BUCKET_URI) embedding_model = VertexAIEmbeddings(model_name="textembedding-gecko@003") Create an empty Index​ Note : While creating an index you should specify an “index_update_method” from either a “BATCH_UPDATE” or “STREAM_UPDATE” > A batch index is for when you want to update your index in a batch, with data which has been stored over a set amount of time, like systems which are processed weekly or monthly. A streaming index is when you want index data to be updated as new data is added to your datastore, for instance, if you have a bookstore and want to show new inventory online as soon as possible. Which type you choose is important, since setup and requirements are different. Refer Official Documentation for more details on configuring indexes # NOTE : This operation can take upto 30 seconds my_index = aiplatform.MatchingEngineIndex.create_tree_ah_index( display_name=DISPLAY_NAME, dimensions=DIMENSIONS, approximate_neighbors_count=150, distance_measure_type="DOT_PRODUCT_DISTANCE", index_update_method="STREAM_UPDATE", # allowed values BATCH_UPDATE , STREAM_UPDATE ) Create an Endpoint​ # Create an endpoint my_index_endpoint = aiplatform.MatchingEngineIndexEndpoint.create( display_name=f"{DISPLAY_NAME}-endpoint", public_endpoint_enabled=True ) Deploy Index to the Endpoint​ # NOTE : This operation can take upto 20 minutes my_index_endpoint = my_index_endpoint.deploy_index( index=my_index, deployed_index_id=DEPLOYED_INDEX_ID ) my_index_endpoint.deployed_indexes Create Vector Store from texts​ from langchain_google_vertexai import ( VectorSearchVectorStore, VectorSearchVectorStoreDatastore, ) Create simple vectorstore ( without filters)​ # Input texts texts = [ "The cat sat on", "the mat.", "I like to", "eat pizza for", "dinner.", "The sun sets", "in the west.", ] # Create a Vector Store vector_store = VectorSearchVectorStore.from_components( project_id=PROJECT_ID, region=REGION, gcs_bucket_name=BUCKET, index_id=my_index.name, endpoint_id=my_index_endpoint.name, embedding=embedding_model, stream_update=True, ) # Add vectors and mapped text chunks to your vectore store vector_store.add_texts(texts=texts) OPTIONAL : You can also create vectore and store chunks in a Datastore​ # NOTE : This operation can take upto 20 mins vector_store = VectorSearchVectorStoreDatastore.from_components( project_id=PROJECT_ID, region=REGION, index_id=my_index.name, endpoint_id=my_index_endpoint.name, embedding=embedding_model, stream_update=True, ) vector_store.add_texts(texts=texts, is_complete_overwrite=True) # Try running a simialarity search vector_store.similarity_search("pizza") Create vectorstore with metadata filters​ # Input text with metadata record_data = [ { "description": "A versatile pair of dark-wash denim jeans." "Made from durable cotton with a classic straight-leg cut, these jeans" " transition easily from casual days to dressier occasions.", "price": 65.00, "color": "blue", "season": ["fall", "winter", "spring"], }, { "description": "A lightweight linen button-down shirt in a crisp white." " Perfect for keeping cool with breathable fabric and a relaxed fit.", "price": 34.99, "color": "white", "season": ["summer", "spring"], }, { "description": "A soft, chunky knit sweater in a vibrant forest green. " "The oversized fit and cozy wool blend make this ideal for staying warm " "when the temperature drops.", "price": 89.99, "color": "green", "season": ["fall", "winter"], }, { "description": "A classic crewneck t-shirt in a soft, heathered blue. " "Made from comfortable cotton jersey, this t-shirt is a wardrobe essential " "that works for every season.", "price": 19.99, "color": "blue", "season": ["fall", "winter", "summer", "spring"], }, { "description": "A flowing midi-skirt in a delicate floral print. " "Lightweight and airy, this skirt adds a touch of feminine style " "to warmer days.", "price": 45.00, "color": "white", "season": ["spring", "summer"], }, ] # Parse and prepare input data texts = [] metadatas = [] for record in record_data: record = record.copy() page_content = record.pop("description") texts.append(page_content) if isinstance(page_content, str): metadata = {**record} metadatas.append(metadata) # Inspect metadatas metadatas # NOTE : This operation can take more than 20 mins vector_store = VectorSearchVectorStore.from_components( project_id=PROJECT_ID, region=REGION, gcs_bucket_name=BUCKET, index_id=my_index.name, endpoint_id=my_index_endpoint.name, embedding=embedding_model, ) vector_store.add_texts(texts=texts, metadatas=metadatas, is_complete_overwrite=True) from google.cloud.aiplatform.matching_engine.matching_engine_index_endpoint import ( Namespace, NumericNamespace, ) # Try running a simple similarity search # Below code should return 5 results vector_store.similarity_search("shirt", k=5) # Try running a similarity search with text filter filters = [Namespace(name="season", allow_tokens=["spring"])] # Below code should return 4 results now vector_store.similarity_search("shirt", k=5, filter=filters) # Try running a similarity search with combination of text and numeric filter filters = [Namespace(name="season", allow_tokens=["spring"])] numeric_filters = [NumericNamespace(name="price", value_float=40.0, op="LESS")] # Below code should return 2 results now vector_store.similarity_search( "shirt", k=5, filter=filters, numeric_filter=numeric_filters ) Use Vector Store as retriever​ # Initialize the vectore_store as retriever retriever = vector_store.as_retriever() # perform simple similarity search on retriever retriever.get_relevant_documents("What are my options in breathable fabric?") # Try running a similarity search with text filter filters = [Namespace(name="season", allow_tokens=["spring"])] retriever.search_kwargs = {"filter": filters} # perform similarity search with filters on retriever retriever.get_relevant_documents("What are my options in breathable fabric?") # Try running a similarity search with combination of text and numeric filter filters = [Namespace(name="season", allow_tokens=["spring"])] numeric_filters = [NumericNamespace(name="price", value_float=40.0, op="LESS")] retriever.search_kwargs = {"filter": filters, "numeric_filter": numeric_filters} retriever.get_relevant_documents("What are my options in breathable fabric?") Use filters with retriever in Question Answering Chains​ from langchain_google_vertexai import VertexAI llm = VertexAI(model_name="gemini-pro") from langchain.chains import RetrievalQA filters = [Namespace(name="season", allow_tokens=["spring"])] numeric_filters = [NumericNamespace(name="price", value_float=40.0, op="LESS")] retriever.search_kwargs = {"k": 2, "filter": filters, "numeric_filter": numeric_filters} retrieval_qa = RetrievalQA.from_chain_type( llm=llm, chain_type="stuff", retriever=retriever, return_source_documents=True, ) question = "What are my options in breathable fabric?" response = retrieval_qa({"query": question}) print(f"{response['result']}") print("REFERENCES") print(f"{response['source_documents']}") Read , Chunk , Vectorise and Index PDFs​ from langchain_community.document_loaders import PyPDFLoader from langchain_text_splitters import RecursiveCharacterTextSplitter loader = PyPDFLoader("https://arxiv.org/pdf/1706.03762.pdf") pages = loader.load() text_splitter = RecursiveCharacterTextSplitter( # Set a really small chunk size, just to show. chunk_size=1000, chunk_overlap=20, length_function=len, is_separator_regex=False, ) doc_splits = text_splitter.split_documents(pages) texts = [doc.page_content for doc in doc_splits] metadatas = [doc.metadata for doc in doc_splits] # Inspect Metadata of 1st page metadatas[0] vector_store = VectorSearchVectorStore.from_components( project_id=PROJECT_ID, region=REGION, gcs_bucket_name=BUCKET, index_id=my_index.name, endpoint_id=my_index_endpoint.name, embedding=embedding_model, ) vector_store.add_texts(texts=texts, metadatas=metadatas, is_complete_overwrite=True) my_index = aiplatform.MatchingEngineIndex("5908955807575179264") my_index_endpoint = aiplatform.MatchingEngineIndexEndpoint("7751631742611488768") vector_store = VectorSearchVectorStore.from_components( project_id=PROJECT_ID, region=REGION, gcs_bucket_name=BUCKET, index_id=my_index.name, endpoint_id=my_index_endpoint.name, embedding=embedding_model, )

https://python.langchain.com/docs/modules/data_connection/document_loaders/custom/

## Custom Document Loader ## Overview[​](#overview "Direct link to Overview") Applications based on LLMs frequently entail extracting data from databases or files, like PDFs, and converting it into a format that LLMs can utilize. In LangChain, this usually involves creating Document objects, which encapsulate the extracted text (`page_content`) along with metadata—a dictionary containing details about the document, such as the author’s name or the date of publication. `Document` objects are often formatted into prompts that are fed into an LLM, allowing the LLM to use the information in the `Document` to generate a desired response (e.g., summarizing the document). `Documents` can be either used immediately or indexed into a vectorstore for future retrieval and use. The main abstractions for Document Loading are: | Component | Description | | --- | --- | | Document | Contains `text` and `metadata` | | BaseLoader | Use to convert raw data into `Documents` | | Blob | A representation of binary data that’s located either in a file or in memory | | BaseBlobParser | Logic to parse a `Blob` to yield `Document` objects | This guide will demonstrate how to write custom document loading and file parsing logic; specifically, we’ll see how to: 1. Create a standard document Loader by sub-classing from `BaseLoader`. 2. Create a parser using `BaseBlobParser` and use it in conjunction with `Blob` and `BlobLoaders`. This is useful primarily when working with files. ## Standard Document Loader[​](#standard-document-loader "Direct link to Standard Document Loader") A document loader can be implemented by sub-classing from a `BaseLoader` which provides a standard interface for loading documents. ### Interface[​](#interface "Direct link to Interface") | Method Name | Explanation | | --- | --- | | lazy\_load | Used to load documents one by one **lazily**. Use for production code. | | alazy\_load | Async variant of `lazy_load` | | load | Used to load all the documents into memory **eagerly**. Use for prototyping or interactive work. | | aload | Used to load all the documents into memory **eagerly**. Use for prototyping or interactive work. **Added in 2024-04 to LangChain.** | * The `load` methods is a convenience method meant solely for prototyping work – it just invokes `list(self.lazy_load())`. * The `alazy_load` has a default implementation that will delegate to `lazy_load`. If you’re using async, we recommend overriding the default implementation and providing a native async implementation. info When implementing a document loader do **NOT** provide parameters via the `lazy_load` or `alazy_load` methods. All configuration is expected to be passed through the initializer (**init**). This was a design choice made by LangChain to make sure that once a document loader has been instantiated it has all the information needed to load documents. ### Implementation[​](#implementation "Direct link to Implementation") Let’s create an example of a standard document loader that loads a file and creates a document from each line in the file. ``` from typing import AsyncIterator, Iteratorfrom langchain_core.document_loaders import BaseLoaderfrom langchain_core.documents import Documentclass CustomDocumentLoader(BaseLoader): """An example document loader that reads a file line by line.""" def __init__(self, file_path: str) -> None: """Initialize the loader with a file path. Args: file_path: The path to the file to load. """ self.file_path = file_path def lazy_load(self) -> Iterator[Document]: # <-- Does not take any arguments """A lazy loader that reads a file line by line. When you're implementing lazy load methods, you should use a generator to yield documents one by one. """ with open(self.file_path, encoding="utf-8") as f: line_number = 0 for line in f: yield Document( page_content=line, metadata={"line_number": line_number, "source": self.file_path}, ) line_number += 1 # alazy_load is OPTIONAL. # If you leave out the implementation, a default implementation which delegates to lazy_load will be used! async def alazy_load( self, ) -> AsyncIterator[Document]: # <-- Does not take any arguments """An async lazy loader that reads a file line by line.""" # Requires aiofiles # Install with `pip install aiofiles` # https://github.com/Tinche/aiofiles import aiofiles async with aiofiles.open(self.file_path, encoding="utf-8") as f: line_number = 0 async for line in f: yield Document( page_content=line, metadata={"line_number": line_number, "source": self.file_path}, ) line_number += 1 ``` ### Test 🧪[​](#test "Direct link to Test 🧪") To test out the document loader, we need a file with some quality content. ``` with open("./meow.txt", "w", encoding="utf-8") as f: quality_content = "meow meow🐱 \n meow meow🐱 \n meow😻😻" f.write(quality_content)loader = CustomDocumentLoader("./meow.txt") ``` ``` ## Test out the lazy load interfacefor doc in loader.lazy_load(): print() print(type(doc)) print(doc) ``` ``` <class 'langchain_core.documents.base.Document'>page_content='meow meow🐱 \n' metadata={'line_number': 0, 'source': './meow.txt'}<class 'langchain_core.documents.base.Document'>page_content=' meow meow🐱 \n' metadata={'line_number': 1, 'source': './meow.txt'}<class 'langchain_core.documents.base.Document'>page_content=' meow😻😻' metadata={'line_number': 2, 'source': './meow.txt'} ``` ``` ## Test out the async implementationasync for doc in loader.alazy_load(): print() print(type(doc)) print(doc) ``` ``` <class 'langchain_core.documents.base.Document'>page_content='meow meow🐱 \n' metadata={'line_number': 0, 'source': './meow.txt'}<class 'langchain_core.documents.base.Document'>page_content=' meow meow🐱 \n' metadata={'line_number': 1, 'source': './meow.txt'}<class 'langchain_core.documents.base.Document'>page_content=' meow😻😻' metadata={'line_number': 2, 'source': './meow.txt'} ``` tip `load()` can be helpful in an interactive environment such as a jupyter notebook. Avoid using it for production code since eager loading assumes that all the content can fit into memory, which is not always the case, especially for enterprise data. ``` [Document(page_content='meow meow🐱 \n', metadata={'line_number': 0, 'source': './meow.txt'}), Document(page_content=' meow meow🐱 \n', metadata={'line_number': 1, 'source': './meow.txt'}), Document(page_content=' meow😻😻', metadata={'line_number': 2, 'source': './meow.txt'})] ``` ## Working with Files[​](#working-with-files "Direct link to Working with Files") Many document loaders invovle parsing files. The difference between such loaders usually stems from how the file is parsed rather than how the file is loaded. For example, you can use `open` to read the binary content of either a PDF or a markdown file, but you need different parsing logic to convert that binary data into text. As a result, it can be helpful to decouple the parsing logic from the loading logic, which makes it easier to re-use a given parser regardless of how the data was loaded. ### BaseBlobParser[​](#baseblobparser "Direct link to BaseBlobParser") A `BaseBlobParser` is an interface that accepts a `blob` and outputs a list of `Document` objects. A `blob` is a representation of data that lives either in memory or in a file. LangChain python has a `Blob` primitive which is inspired by the [Blob WebAPI spec](https://developer.mozilla.org/en-US/docs/Web/API/Blob). ``` from langchain_core.document_loaders import BaseBlobParser, Blobclass MyParser(BaseBlobParser): """A simple parser that creates a document from each line.""" def lazy_parse(self, blob: Blob) -> Iterator[Document]: """Parse a blob into a document line by line.""" line_number = 0 with blob.as_bytes_io() as f: for line in f: line_number += 1 yield Document( page_content=line, metadata={"line_number": line_number, "source": blob.source}, ) ``` ``` blob = Blob.from_path("./meow.txt")parser = MyParser() ``` ``` list(parser.lazy_parse(blob)) ``` ``` [Document(page_content='meow meow🐱 \n', metadata={'line_number': 1, 'source': './meow.txt'}), Document(page_content=' meow meow🐱 \n', metadata={'line_number': 2, 'source': './meow.txt'}), Document(page_content=' meow😻😻', metadata={'line_number': 3, 'source': './meow.txt'})] ``` Using the **blob** API also allows one to load content direclty from memory without having to read it from a file! ``` blob = Blob(data=b"some data from memory\nmeow")list(parser.lazy_parse(blob)) ``` ``` [Document(page_content='some data from memory\n', metadata={'line_number': 1, 'source': None}), Document(page_content='meow', metadata={'line_number': 2, 'source': None})] ``` ### Blob[​](#blob "Direct link to Blob") Let’s take a quick look through some of the Blob API. ``` blob = Blob.from_path("./meow.txt", metadata={"foo": "bar"}) ``` ``` b'meow meow\xf0\x9f\x90\xb1 \n meow meow\xf0\x9f\x90\xb1 \n meow\xf0\x9f\x98\xbb\xf0\x9f\x98\xbb' ``` ``` 'meow meow🐱 \n meow meow🐱 \n meow😻😻' ``` ``` <contextlib._GeneratorContextManager at 0x743f34324450> ``` ### Blob Loaders[​](#blob-loaders "Direct link to Blob Loaders") While a parser encapsulates the logic needed to parse binary data into documents, _blob loaders_ encapsulate the logic that’s necessary to load blobs from a given storage location. A the moment, `LangChain` only supports `FileSystemBlobLoader`. You can use the `FileSystemBlobLoader` to load blobs and then use the parser to parse them. ``` from langchain_community.document_loaders.blob_loaders import FileSystemBlobLoaderblob_loader = FileSystemBlobLoader(path=".", glob="*.mdx", show_progress=True) ``` ``` parser = MyParser()for blob in blob_loader.yield_blobs(): for doc in parser.lazy_parse(blob): print(doc) break ``` ``` 0%| | 0/8 [00:00<?, ?it/s] ``` ``` page_content='# Microsoft Office\n' metadata={'line_number': 1, 'source': 'office_file.mdx'}page_content='# Markdown\n' metadata={'line_number': 1, 'source': 'markdown.mdx'}page_content='# JSON\n' metadata={'line_number': 1, 'source': 'json.mdx'}page_content='---\n' metadata={'line_number': 1, 'source': 'pdf.mdx'}page_content='---\n' metadata={'line_number': 1, 'source': 'index.mdx'}page_content='# File Directory\n' metadata={'line_number': 1, 'source': 'file_directory.mdx'}page_content='# CSV\n' metadata={'line_number': 1, 'source': 'csv.mdx'}page_content='# HTML\n' metadata={'line_number': 1, 'source': 'html.mdx'} ``` ### Generic Loader[​](#generic-loader "Direct link to Generic Loader") LangChain has a `GenericLoader` abstraction which composes a `BlobLoader` with a `BaseBlobParser`. `GenericLoader` is meant to provide standardized classmethods that make it easy to use existing `BlobLoader` implementations. At the moment, only the `FileSystemBlobLoader` is supported. ``` from langchain_community.document_loaders.generic import GenericLoaderloader = GenericLoader.from_filesystem( path=".", glob="*.mdx", show_progress=True, parser=MyParser())for idx, doc in enumerate(loader.lazy_load()): if idx < 5: print(doc)print("... output truncated for demo purposes") ``` ``` 0%| | 0/8 [00:00<?, ?it/s] ``` ``` page_content='# Microsoft Office\n' metadata={'line_number': 1, 'source': 'office_file.mdx'}page_content='\n' metadata={'line_number': 2, 'source': 'office_file.mdx'}page_content='>[The Microsoft Office](https://www.office.com/) suite of productivity software includes Microsoft Word, Microsoft Excel, Microsoft PowerPoint, Microsoft Outlook, and Microsoft OneNote. It is available for Microsoft Windows and macOS operating systems. It is also available on Android and iOS.\n' metadata={'line_number': 3, 'source': 'office_file.mdx'}page_content='\n' metadata={'line_number': 4, 'source': 'office_file.mdx'}page_content='This covers how to load commonly used file formats including `DOCX`, `XLSX` and `PPTX` documents into a document format that we can use downstream.\n' metadata={'line_number': 5, 'source': 'office_file.mdx'}... output truncated for demo purposes ``` #### Custom Generic Loader[​](#custom-generic-loader "Direct link to Custom Generic Loader") If you really like creating classes, you can sub-class and create a class to encapsulate the logic together. You can sub-class from this class to load content using an existing loader. ``` from typing import Anyclass MyCustomLoader(GenericLoader): @staticmethod def get_parser(**kwargs: Any) -> BaseBlobParser: """Override this method to associate a default parser with the class.""" return MyParser() ``` ``` loader = MyCustomLoader.from_filesystem(path=".", glob="*.mdx", show_progress=True)for idx, doc in enumerate(loader.lazy_load()): if idx < 5: print(doc)print("... output truncated for demo purposes") ``` ``` 0%| | 0/8 [00:00<?, ?it/s] ``` ``` page_content='# Microsoft Office\n' metadata={'line_number': 1, 'source': 'office_file.mdx'}page_content='\n' metadata={'line_number': 2, 'source': 'office_file.mdx'}page_content='>[The Microsoft Office](https://www.office.com/) suite of productivity software includes Microsoft Word, Microsoft Excel, Microsoft PowerPoint, Microsoft Outlook, and Microsoft OneNote. It is available for Microsoft Windows and macOS operating systems. It is also available on Android and iOS.\n' metadata={'line_number': 3, 'source': 'office_file.mdx'}page_content='\n' metadata={'line_number': 4, 'source': 'office_file.mdx'}page_content='This covers how to load commonly used file formats including `DOCX`, `XLSX` and `PPTX` documents into a document format that we can use downstream.\n' metadata={'line_number': 5, 'source': 'office_file.mdx'}... output truncated for demo purposes ```

Custom Document Loader Overview​ Applications based on LLMs frequently entail extracting data from databases or files, like PDFs, and converting it into a format that LLMs can utilize. In LangChain, this usually involves creating Document objects, which encapsulate the extracted text (page_content) along with metadata—a dictionary containing details about the document, such as the author’s name or the date of publication. Document objects are often formatted into prompts that are fed into an LLM, allowing the LLM to use the information in the Document to generate a desired response (e.g., summarizing the document). Documents can be either used immediately or indexed into a vectorstore for future retrieval and use. The main abstractions for Document Loading are: ComponentDescription Document Contains text and metadata BaseLoader Use to convert raw data into Documents Blob A representation of binary data that’s located either in a file or in memory BaseBlobParser Logic to parse a Blob to yield Document objects This guide will demonstrate how to write custom document loading and file parsing logic; specifically, we’ll see how to: Create a standard document Loader by sub-classing from BaseLoader. Create a parser using BaseBlobParser and use it in conjunction with Blob and BlobLoaders. This is useful primarily when working with files. Standard Document Loader​ A document loader can be implemented by sub-classing from a BaseLoader which provides a standard interface for loading documents. Interface​ Method NameExplanation lazy_load Used to load documents one by one lazily. Use for production code. alazy_load Async variant of lazy_load load Used to load all the documents into memory eagerly. Use for prototyping or interactive work. aload Used to load all the documents into memory eagerly. Use for prototyping or interactive work. Added in 2024-04 to LangChain. The load methods is a convenience method meant solely for prototyping work – it just invokes list(self.lazy_load()). The alazy_load has a default implementation that will delegate to lazy_load. If you’re using async, we recommend overriding the default implementation and providing a native async implementation. info When implementing a document loader do NOT provide parameters via the lazy_load or alazy_load methods. All configuration is expected to be passed through the initializer (init). This was a design choice made by LangChain to make sure that once a document loader has been instantiated it has all the information needed to load documents. Implementation​ Let’s create an example of a standard document loader that loads a file and creates a document from each line in the file. from typing import AsyncIterator, Iterator from langchain_core.document_loaders import BaseLoader from langchain_core.documents import Document class CustomDocumentLoader(BaseLoader): """An example document loader that reads a file line by line.""" def __init__(self, file_path: str) -> None: """Initialize the loader with a file path. Args: file_path: The path to the file to load. """ self.file_path = file_path def lazy_load(self) -> Iterator[Document]: # <-- Does not take any arguments """A lazy loader that reads a file line by line. When you're implementing lazy load methods, you should use a generator to yield documents one by one. """ with open(self.file_path, encoding="utf-8") as f: line_number = 0 for line in f: yield Document( page_content=line, metadata={"line_number": line_number, "source": self.file_path}, ) line_number += 1 # alazy_load is OPTIONAL. # If you leave out the implementation, a default implementation which delegates to lazy_load will be used! async def alazy_load( self, ) -> AsyncIterator[Document]: # <-- Does not take any arguments """An async lazy loader that reads a file line by line.""" # Requires aiofiles # Install with `pip install aiofiles` # https://github.com/Tinche/aiofiles import aiofiles async with aiofiles.open(self.file_path, encoding="utf-8") as f: line_number = 0 async for line in f: yield Document( page_content=line, metadata={"line_number": line_number, "source": self.file_path}, ) line_number += 1 Test 🧪​ To test out the document loader, we need a file with some quality content. with open("./meow.txt", "w", encoding="utf-8") as f: quality_content = "meow meow🐱 \n meow meow🐱 \n meow😻😻" f.write(quality_content) loader = CustomDocumentLoader("./meow.txt") ## Test out the lazy load interface for doc in loader.lazy_load(): print() print(type(doc)) print(doc) <class 'langchain_core.documents.base.Document'> page_content='meow meow🐱 \n' metadata={'line_number': 0, 'source': './meow.txt'} <class 'langchain_core.documents.base.Document'> page_content=' meow meow🐱 \n' metadata={'line_number': 1, 'source': './meow.txt'} <class 'langchain_core.documents.base.Document'> page_content=' meow😻😻' metadata={'line_number': 2, 'source': './meow.txt'} ## Test out the async implementation async for doc in loader.alazy_load(): print() print(type(doc)) print(doc) <class 'langchain_core.documents.base.Document'> page_content='meow meow🐱 \n' metadata={'line_number': 0, 'source': './meow.txt'} <class 'langchain_core.documents.base.Document'> page_content=' meow meow🐱 \n' metadata={'line_number': 1, 'source': './meow.txt'} <class 'langchain_core.documents.base.Document'> page_content=' meow😻😻' metadata={'line_number': 2, 'source': './meow.txt'} tip load() can be helpful in an interactive environment such as a jupyter notebook. Avoid using it for production code since eager loading assumes that all the content can fit into memory, which is not always the case, especially for enterprise data. [Document(page_content='meow meow🐱 \n', metadata={'line_number': 0, 'source': './meow.txt'}), Document(page_content=' meow meow🐱 \n', metadata={'line_number': 1, 'source': './meow.txt'}), Document(page_content=' meow😻😻', metadata={'line_number': 2, 'source': './meow.txt'})] Working with Files​ Many document loaders invovle parsing files. The difference between such loaders usually stems from how the file is parsed rather than how the file is loaded. For example, you can use open to read the binary content of either a PDF or a markdown file, but you need different parsing logic to convert that binary data into text. As a result, it can be helpful to decouple the parsing logic from the loading logic, which makes it easier to re-use a given parser regardless of how the data was loaded. BaseBlobParser​ A BaseBlobParser is an interface that accepts a blob and outputs a list of Document objects. A blob is a representation of data that lives either in memory or in a file. LangChain python has a Blob primitive which is inspired by the Blob WebAPI spec. from langchain_core.document_loaders import BaseBlobParser, Blob class MyParser(BaseBlobParser): """A simple parser that creates a document from each line.""" def lazy_parse(self, blob: Blob) -> Iterator[Document]: """Parse a blob into a document line by line.""" line_number = 0 with blob.as_bytes_io() as f: for line in f: line_number += 1 yield Document( page_content=line, metadata={"line_number": line_number, "source": blob.source}, ) blob = Blob.from_path("./meow.txt") parser = MyParser() list(parser.lazy_parse(blob)) [Document(page_content='meow meow🐱 \n', metadata={'line_number': 1, 'source': './meow.txt'}), Document(page_content=' meow meow🐱 \n', metadata={'line_number': 2, 'source': './meow.txt'}), Document(page_content=' meow😻😻', metadata={'line_number': 3, 'source': './meow.txt'})] Using the blob API also allows one to load content direclty from memory without having to read it from a file! blob = Blob(data=b"some data from memory\nmeow") list(parser.lazy_parse(blob)) [Document(page_content='some data from memory\n', metadata={'line_number': 1, 'source': None}), Document(page_content='meow', metadata={'line_number': 2, 'source': None})] Blob​ Let’s take a quick look through some of the Blob API. blob = Blob.from_path("./meow.txt", metadata={"foo": "bar"}) b'meow meow\xf0\x9f\x90\xb1 \n meow meow\xf0\x9f\x90\xb1 \n meow\xf0\x9f\x98\xbb\xf0\x9f\x98\xbb' 'meow meow🐱 \n meow meow🐱 \n meow😻😻' <contextlib._GeneratorContextManager at 0x743f34324450> Blob Loaders​ While a parser encapsulates the logic needed to parse binary data into documents, blob loaders encapsulate the logic that’s necessary to load blobs from a given storage location. A the moment, LangChain only supports FileSystemBlobLoader. You can use the FileSystemBlobLoader to load blobs and then use the parser to parse them. from langchain_community.document_loaders.blob_loaders import FileSystemBlobLoader blob_loader = FileSystemBlobLoader(path=".", glob="*.mdx", show_progress=True) parser = MyParser() for blob in blob_loader.yield_blobs(): for doc in parser.lazy_parse(blob): print(doc) break 0%| | 0/8 [00:00<?, ?it/s] page_content='# Microsoft Office\n' metadata={'line_number': 1, 'source': 'office_file.mdx'} page_content='# Markdown\n' metadata={'line_number': 1, 'source': 'markdown.mdx'} page_content='# JSON\n' metadata={'line_number': 1, 'source': 'json.mdx'} page_content='---\n' metadata={'line_number': 1, 'source': 'pdf.mdx'} page_content='---\n' metadata={'line_number': 1, 'source': 'index.mdx'} page_content='# File Directory\n' metadata={'line_number': 1, 'source': 'file_directory.mdx'} page_content='# CSV\n' metadata={'line_number': 1, 'source': 'csv.mdx'} page_content='# HTML\n' metadata={'line_number': 1, 'source': 'html.mdx'} Generic Loader​ LangChain has a GenericLoader abstraction which composes a BlobLoader with a BaseBlobParser. GenericLoader is meant to provide standardized classmethods that make it easy to use existing BlobLoader implementations. At the moment, only the FileSystemBlobLoader is supported. from langchain_community.document_loaders.generic import GenericLoader loader = GenericLoader.from_filesystem( path=".", glob="*.mdx", show_progress=True, parser=MyParser() ) for idx, doc in enumerate(loader.lazy_load()): if idx < 5: print(doc) print("... output truncated for demo purposes") 0%| | 0/8 [00:00<?, ?it/s] page_content='# Microsoft Office\n' metadata={'line_number': 1, 'source': 'office_file.mdx'} page_content='\n' metadata={'line_number': 2, 'source': 'office_file.mdx'} page_content='>[The Microsoft Office](https://www.office.com/) suite of productivity software includes Microsoft Word, Microsoft Excel, Microsoft PowerPoint, Microsoft Outlook, and Microsoft OneNote. It is available for Microsoft Windows and macOS operating systems. It is also available on Android and iOS.\n' metadata={'line_number': 3, 'source': 'office_file.mdx'} page_content='\n' metadata={'line_number': 4, 'source': 'office_file.mdx'} page_content='This covers how to load commonly used file formats including `DOCX`, `XLSX` and `PPTX` documents into a document format that we can use downstream.\n' metadata={'line_number': 5, 'source': 'office_file.mdx'} ... output truncated for demo purposes Custom Generic Loader​ If you really like creating classes, you can sub-class and create a class to encapsulate the logic together. You can sub-class from this class to load content using an existing loader. from typing import Any class MyCustomLoader(GenericLoader): @staticmethod def get_parser(**kwargs: Any) -> BaseBlobParser: """Override this method to associate a default parser with the class.""" return MyParser() loader = MyCustomLoader.from_filesystem(path=".", glob="*.mdx", show_progress=True) for idx, doc in enumerate(loader.lazy_load()): if idx < 5: print(doc) print("... output truncated for demo purposes") 0%| | 0/8 [00:00<?, ?it/s] page_content='# Microsoft Office\n' metadata={'line_number': 1, 'source': 'office_file.mdx'} page_content='\n' metadata={'line_number': 2, 'source': 'office_file.mdx'} page_content='>[The Microsoft Office](https://www.office.com/) suite of productivity software includes Microsoft Word, Microsoft Excel, Microsoft PowerPoint, Microsoft Outlook, and Microsoft OneNote. It is available for Microsoft Windows and macOS operating systems. It is also available on Android and iOS.\n' metadata={'line_number': 3, 'source': 'office_file.mdx'} page_content='\n' metadata={'line_number': 4, 'source': 'office_file.mdx'} page_content='This covers how to load commonly used file formats including `DOCX`, `XLSX` and `PPTX` documents into a document format that we can use downstream.\n' metadata={'line_number': 5, 'source': 'office_file.mdx'} ... output truncated for demo purposes

https://python.langchain.com/docs/modules/agents/agent_types/self_ask_with_search/

## Self-ask with search This walkthrough showcases the self-ask with search agent. ``` from langchain import hubfrom langchain.agents import AgentExecutor, create_self_ask_with_search_agentfrom langchain_community.llms import Fireworksfrom langchain_community.tools.tavily_search import TavilyAnswer ``` We will initialize the tools we want to use. This is a good tool because it gives us **answers** (not documents) For this agent, only one tool can be used and it needs to be named “Intermediate Answer” ``` tools = [TavilyAnswer(max_results=1, name="Intermediate Answer")] ``` ## Create Agent[​](#create-agent "Direct link to Create Agent") ``` # Get the prompt to use - you can modify this!prompt = hub.pull("hwchase17/self-ask-with-search") ``` ``` # Choose the LLM that will drive the agentllm = Fireworks()# Construct the Self Ask With Search Agentagent = create_self_ask_with_search_agent(llm, tools, prompt) ``` ## Run Agent[​](#run-agent "Direct link to Run Agent") ``` # Create an agent executor by passing in the agent and toolsagent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) ``` ``` agent_executor.invoke( {"input": "What is the hometown of the reigning men's U.S. Open champion?"}) ``` ``` > Entering new AgentExecutor chain... Yes.Follow up: Who is the reigning men's U.S. Open champion?The reigning men's U.S. Open champion is Novak Djokovic. He won his 24th Grand Slam singles title by defeating Daniil Medvedev in the final of the 2023 U.S. Open.So the final answer is: Novak Djokovic.> Finished chain. ``` ``` {'input': "What is the hometown of the reigning men's U.S. Open champion?", 'output': 'Novak Djokovic.'} ``` * * * #### Help us out by providing feedback on this documentation page:

Self-ask with search This walkthrough showcases the self-ask with search agent. from langchain import hub from langchain.agents import AgentExecutor, create_self_ask_with_search_agent from langchain_community.llms import Fireworks from langchain_community.tools.tavily_search import TavilyAnswer We will initialize the tools we want to use. This is a good tool because it gives us answers (not documents) For this agent, only one tool can be used and it needs to be named “Intermediate Answer” tools = [TavilyAnswer(max_results=1, name="Intermediate Answer")] Create Agent​ # Get the prompt to use - you can modify this! prompt = hub.pull("hwchase17/self-ask-with-search") # Choose the LLM that will drive the agent llm = Fireworks() # Construct the Self Ask With Search Agent agent = create_self_ask_with_search_agent(llm, tools, prompt) Run Agent​ # Create an agent executor by passing in the agent and tools agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) agent_executor.invoke( {"input": "What is the hometown of the reigning men's U.S. Open champion?"} ) > Entering new AgentExecutor chain... Yes. Follow up: Who is the reigning men's U.S. Open champion?The reigning men's U.S. Open champion is Novak Djokovic. He won his 24th Grand Slam singles title by defeating Daniil Medvedev in the final of the 2023 U.S. Open. So the final answer is: Novak Djokovic. > Finished chain. {'input': "What is the hometown of the reigning men's U.S. Open champion?", 'output': 'Novak Djokovic.'} Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/modules/agents/agent_types/structured_chat/

## Structured chat The structured chat agent is capable of using multi-input tools. ``` from langchain import hubfrom langchain.agents import AgentExecutor, create_structured_chat_agentfrom langchain_community.tools.tavily_search import TavilySearchResultsfrom langchain_openai import ChatOpenAI ``` We will test the agent using Tavily Search ``` tools = [TavilySearchResults(max_results=1)] ``` ## Create Agent[​](#create-agent "Direct link to Create Agent") ``` # Get the prompt to use - you can modify this!prompt = hub.pull("hwchase17/structured-chat-agent") ``` ``` # Choose the LLM that will drive the agentllm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-1106")# Construct the JSON agentagent = create_structured_chat_agent(llm, tools, prompt) ``` ## Run Agent[​](#run-agent "Direct link to Run Agent") ``` # Create an agent executor by passing in the agent and toolsagent_executor = AgentExecutor( agent=agent, tools=tools, verbose=True, handle_parsing_errors=True) ``` ``` agent_executor.invoke({"input": "what is LangChain?"}) ``` ``` > Entering new AgentExecutor chain...Action:```{ "action": "tavily_search_results_json", "action_input": {"query": "LangChain"}}```[{'url': 'https://www.ibm.com/topics/langchain', 'content': 'LangChain is essentially a library of abstractions for Python and Javascript, representing common steps and concepts LangChain is an open source orchestration framework for the development of applications using large language models other LangChain features, like the eponymous chains. LangChain provides integrations for over 25 different embedding methods, as well as for over 50 different vector storesLangChain is a tool for building applications using large language models (LLMs) like chatbots and virtual agents. It simplifies the process of programming and integration with external data sources and software workflows. It supports Python and Javascript languages and supports various LLM providers, including OpenAI, Google, and IBM.'}]Action:```{ "action": "Final Answer", "action_input": "LangChain is an open source orchestration framework for the development of applications using large language models. It simplifies the process of programming and integration with external data sources and software workflows. LangChain provides integrations for over 25 different embedding methods and supports various large language model providers such as OpenAI, Google, and IBM. It supports Python and Javascript languages."}```> Finished chain. ``` ``` {'input': 'what is LangChain?', 'output': 'LangChain is an open source orchestration framework for the development of applications using large language models. It simplifies the process of programming and integration with external data sources and software workflows. LangChain provides integrations for over 25 different embedding methods and supports various large language model providers such as OpenAI, Google, and IBM. It supports Python and Javascript languages.'} ``` ## Use with chat history[​](#use-with-chat-history "Direct link to Use with chat history") ``` from langchain_core.messages import AIMessage, HumanMessageagent_executor.invoke( { "input": "what's my name? Do not use tools unless you have to", "chat_history": [ HumanMessage(content="hi! my name is bob"), AIMessage(content="Hello Bob! How can I assist you today?"), ], }) ``` ``` > Entering new AgentExecutor chain...Could not parse LLM output: I understand. Your name is Bob.Invalid or incomplete responseCould not parse LLM output: Apologies for any confusion. Your name is Bob.Invalid or incomplete response{ "action": "Final Answer", "action_input": "Your name is Bob."}> Finished chain. ``` ``` {'input': "what's my name? Do not use tools unless you have to", 'chat_history': [HumanMessage(content='hi! my name is bob'), AIMessage(content='Hello Bob! How can I assist you today?')], 'output': 'Your name is Bob.'} ``` * * * #### Help us out by providing feedback on this documentation page:

Structured chat The structured chat agent is capable of using multi-input tools. from langchain import hub from langchain.agents import AgentExecutor, create_structured_chat_agent from langchain_community.tools.tavily_search import TavilySearchResults from langchain_openai import ChatOpenAI We will test the agent using Tavily Search tools = [TavilySearchResults(max_results=1)] Create Agent​ # Get the prompt to use - you can modify this! prompt = hub.pull("hwchase17/structured-chat-agent") # Choose the LLM that will drive the agent llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-1106") # Construct the JSON agent agent = create_structured_chat_agent(llm, tools, prompt) Run Agent​ # Create an agent executor by passing in the agent and tools agent_executor = AgentExecutor( agent=agent, tools=tools, verbose=True, handle_parsing_errors=True ) agent_executor.invoke({"input": "what is LangChain?"}) > Entering new AgentExecutor chain... Action: ``` { "action": "tavily_search_results_json", "action_input": {"query": "LangChain"} } ```[{'url': 'https://www.ibm.com/topics/langchain', 'content': 'LangChain is essentially a library of abstractions for Python and Javascript, representing common steps and concepts LangChain is an open source orchestration framework for the development of applications using large language models other LangChain features, like the eponymous chains. LangChain provides integrations for over 25 different embedding methods, as well as for over 50 different vector storesLangChain is a tool for building applications using large language models (LLMs) like chatbots and virtual agents. It simplifies the process of programming and integration with external data sources and software workflows. It supports Python and Javascript languages and supports various LLM providers, including OpenAI, Google, and IBM.'}]Action: ``` { "action": "Final Answer", "action_input": "LangChain is an open source orchestration framework for the development of applications using large language models. It simplifies the process of programming and integration with external data sources and software workflows. LangChain provides integrations for over 25 different embedding methods and supports various large language model providers such as OpenAI, Google, and IBM. It supports Python and Javascript languages." } ``` > Finished chain. {'input': 'what is LangChain?', 'output': 'LangChain is an open source orchestration framework for the development of applications using large language models. It simplifies the process of programming and integration with external data sources and software workflows. LangChain provides integrations for over 25 different embedding methods and supports various large language model providers such as OpenAI, Google, and IBM. It supports Python and Javascript languages.'} Use with chat history​ from langchain_core.messages import AIMessage, HumanMessage agent_executor.invoke( { "input": "what's my name? Do not use tools unless you have to", "chat_history": [ HumanMessage(content="hi! my name is bob"), AIMessage(content="Hello Bob! How can I assist you today?"), ], } ) > Entering new AgentExecutor chain... Could not parse LLM output: I understand. Your name is Bob.Invalid or incomplete responseCould not parse LLM output: Apologies for any confusion. Your name is Bob.Invalid or incomplete response{ "action": "Final Answer", "action_input": "Your name is Bob." } > Finished chain. {'input': "what's my name? Do not use tools unless you have to", 'chat_history': [HumanMessage(content='hi! my name is bob'), AIMessage(content='Hello Bob! How can I assist you today?')], 'output': 'Your name is Bob.'} Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/modules/agents/agent_types/xml_agent/

## XML Agent Some language models (like Anthropic’s Claude) are particularly good at reasoning/writing XML. This goes over how to use an agent that uses XML when prompting. tip * Use with regular LLMs, not with chat models. * Use only with unstructured tools; i.e., tools that accept a single string input. * See [AgentTypes](https://python.langchain.com/docs/modules/agents/agent_types/) documentation for more agent types. ``` from langchain import hubfrom langchain.agents import AgentExecutor, create_xml_agentfrom langchain_anthropic.chat_models import ChatAnthropicfrom langchain_community.tools.tavily_search import TavilySearchResults ``` We will initialize the tools we want to use ``` tools = [TavilySearchResults(max_results=1)] ``` ## Create Agent[​](#create-agent "Direct link to Create Agent") Below we will use LangChain’s built-in [create\_xml\_agent](https://api.python.langchain.com/en/latest/agents/langchain.agents.xml.base.create_xml_agent.html) constructor. ``` # Get the prompt to use - you can modify this!prompt = hub.pull("hwchase17/xml-agent-convo") ``` ``` # Choose the LLM that will drive the agentllm = ChatAnthropic(model="claude-2.1")# Construct the XML agentagent = create_xml_agent(llm, tools, prompt) ``` ## Run Agent[​](#run-agent "Direct link to Run Agent") ``` # Create an agent executor by passing in the agent and toolsagent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) ``` ``` agent_executor.invoke({"input": "what is LangChain?"}) ``` ``` > Entering new AgentExecutor chain... <tool>tavily_search_results_json</tool><tool_input>what is LangChain?[{'url': 'https://aws.amazon.com/what-is/langchain/', 'content': 'What Is LangChain? What is LangChain? How does LangChain work? Why is LangChain important? that LangChain provides to reduce development time.LangChain is an open source framework for building applications based on large language models (LLMs). LLMs are large deep-learning models pre-trained on large amounts of data that can generate responses to user queries—for example, answering questions or creating images from text-based prompts.'}] <final_answer>LangChain is an open source framework for building applications based on large language models (LLMs). It allows developers to leverage the power of LLMs to create applications that can generate responses to user queries, such as answering questions or creating images from text prompts. Key benefits of LangChain are reducing development time and effort compared to building custom LLMs from scratch.</final_answer>> Finished chain. ``` ``` {'input': 'what is LangChain?', 'output': 'LangChain is an open source framework for building applications based on large language models (LLMs). It allows developers to leverage the power of LLMs to create applications that can generate responses to user queries, such as answering questions or creating images from text prompts. Key benefits of LangChain are reducing development time and effort compared to building custom LLMs from scratch.'} ``` ## Using with chat history[​](#using-with-chat-history "Direct link to Using with chat history") ``` from langchain_core.messages import AIMessage, HumanMessageagent_executor.invoke( { "input": "what's my name? Only use a tool if needed, otherwise respond with Final Answer", # Notice that chat_history is a string, since this prompt is aimed at LLMs, not chat models "chat_history": "Human: Hi! My name is Bob\nAI: Hello Bob! Nice to meet you", }) ``` ``` > Entering new AgentExecutor chain... <final_answer>Your name is Bob.</final_answer>Since you already told me your name is Bob, I do not need to use any tools to answer the question "what's my name?". I can provide the final answer directly that your name is Bob.> Finished chain. ``` ``` {'input': "what's my name? Only use a tool if needed, otherwise respond with Final Answer", 'chat_history': 'Human: Hi! My name is Bob\nAI: Hello Bob! Nice to meet you', 'output': 'Your name is Bob.'} ``` ## Custom XML Agents **Note:** For greater customizability, we recommend checking out [LangGraph](https://python.langchain.com/docs/langgraph/). Here we provide an example of a custom XML Agent implementation, to give a sense for what `create_xml_agent` is doing under the hood. ``` from langchain.agents.output_parsers import XMLAgentOutputParser ``` ``` # Logic for going from intermediate steps to a string to pass into model# This is pretty tied to the promptdef convert_intermediate_steps(intermediate_steps): log = "" for action, observation in intermediate_steps: log += ( f"<tool>{action.tool}</tool><tool_input>{action.tool_input}" f"</tool_input><observation>{observation}</observation>" ) return log# Logic for converting tools to string to go in promptdef convert_tools(tools): return "\n".join([f"{tool.name}: {tool.description}" for tool in tools]) ``` Building an agent from a runnable usually involves a few things: 1. Data processing for the intermediate steps. These need to be represented in a way that the language model can recognize them. This should be pretty tightly coupled to the instructions in the prompt 2. The prompt itself 3. The model, complete with stop tokens if needed 4. The output parser - should be in sync with how the prompt specifies things to be formatted. ``` agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: convert_intermediate_steps( x["intermediate_steps"] ), } | prompt.partial(tools=convert_tools(tools)) | llm.bind(stop=["</tool_input>", "</final_answer>"]) | XMLAgentOutputParser()) ``` ``` agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) ``` ``` agent_executor.invoke({"input": "what is LangChain?"}) ``` ``` > Entering new AgentExecutor chain...<tool>tavily_search_results_json</tool><tool_input>what is LangChain[{'url': 'https://www.techtarget.com/searchEnterpriseAI/definition/LangChain', 'content': "Everything you need to know\nWhat are the features of LangChain?\nLangChain is made up of the following modules that ensure the multiple components needed to make an effective NLP app can run smoothly:\nWhat are the integrations of LangChain?\nLangChain typically builds applications using integrations with LLM providers and external sources where data can be found and stored. What is synthetic data?\nExamples and use cases for LangChain\nThe LLM-based applications LangChain is capable of building can be applied to multiple advanced use cases within various industries and vertical markets, such as the following:\nReaping the benefits of NLP is a key of why LangChain is important. As the airline giant moves more of its data workloads to the cloud, tools from Intel's Granulate are making platforms such as ...\nThe vendor's new platform, now in beta testing, combines its existing lakehouse with AI to better enable users to manage and ...\n The following steps are required to use this:\nIn this scenario, the language model would be expected to take the two input variables -- the adjective and the content -- and produce a fascinating fact about zebras as its output.\n The goal of LangChain is to link powerful LLMs, such as OpenAI's GPT-3.5 and GPT-4, to an array of external data sources to create and reap the benefits of natural language processing (NLP) applications.\n"}]<final_answer>LangChain is a platform developed by Anthropic that enables users to build NLP applications by linking large language models like GPT-3.5 and GPT-4 to external data sources. It provides modules for managing and integrating different components needed for NLP apps.Some key capabilities and features of LangChain:- Allows linking LLMs to external data sources to create customized NLP apps- Provides modules to manage integration of LLMs, data sources, storage etc. - Enables building conversational AI apps, summarization, search, and other NLP capabilities- Helps users reap benefits of NLP and LLMs for use cases across industriesSo in summary, it is a platform to build and deploy advanced NLP models by leveraging capabilities of large language models in a more customizable and scalable way.> Finished chain. ``` ``` {'input': 'what is LangChain?', 'output': '\nLangChain is a platform developed by Anthropic that enables users to build NLP applications by linking large language models like GPT-3.5 and GPT-4 to external data sources. It provides modules for managing and integrating different components needed for NLP apps.\n\nSome key capabilities and features of LangChain:\n\n- Allows linking LLMs to external data sources to create customized NLP apps\n- Provides modules to manage integration of LLMs, data sources, storage etc. \n- Enables building conversational AI apps, summarization, search, and other NLP capabilities\n- Helps users reap benefits of NLP and LLMs for use cases across industries\n\nSo in summary, it is a platform to build and deploy advanced NLP models by leveraging capabilities of large language models in a more customizable and scalable way.\n\n'} ```

XML Agent Some language models (like Anthropic’s Claude) are particularly good at reasoning/writing XML. This goes over how to use an agent that uses XML when prompting. tip Use with regular LLMs, not with chat models. Use only with unstructured tools; i.e., tools that accept a single string input. See AgentTypes documentation for more agent types. from langchain import hub from langchain.agents import AgentExecutor, create_xml_agent from langchain_anthropic.chat_models import ChatAnthropic from langchain_community.tools.tavily_search import TavilySearchResults We will initialize the tools we want to use tools = [TavilySearchResults(max_results=1)] Create Agent​ Below we will use LangChain’s built-in create_xml_agent constructor. # Get the prompt to use - you can modify this! prompt = hub.pull("hwchase17/xml-agent-convo") # Choose the LLM that will drive the agent llm = ChatAnthropic(model="claude-2.1") # Construct the XML agent agent = create_xml_agent(llm, tools, prompt) Run Agent​ # Create an agent executor by passing in the agent and tools agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) agent_executor.invoke({"input": "what is LangChain?"}) > Entering new AgentExecutor chain... <tool>tavily_search_results_json</tool><tool_input>what is LangChain?[{'url': 'https://aws.amazon.com/what-is/langchain/', 'content': 'What Is LangChain? What is LangChain? How does LangChain work? Why is LangChain important? that LangChain provides to reduce development time.LangChain is an open source framework for building applications based on large language models (LLMs). LLMs are large deep-learning models pre-trained on large amounts of data that can generate responses to user queries—for example, answering questions or creating images from text-based prompts.'}] <final_answer>LangChain is an open source framework for building applications based on large language models (LLMs). It allows developers to leverage the power of LLMs to create applications that can generate responses to user queries, such as answering questions or creating images from text prompts. Key benefits of LangChain are reducing development time and effort compared to building custom LLMs from scratch.</final_answer> > Finished chain. {'input': 'what is LangChain?', 'output': 'LangChain is an open source framework for building applications based on large language models (LLMs). It allows developers to leverage the power of LLMs to create applications that can generate responses to user queries, such as answering questions or creating images from text prompts. Key benefits of LangChain are reducing development time and effort compared to building custom LLMs from scratch.'} Using with chat history​ from langchain_core.messages import AIMessage, HumanMessage agent_executor.invoke( { "input": "what's my name? Only use a tool if needed, otherwise respond with Final Answer", # Notice that chat_history is a string, since this prompt is aimed at LLMs, not chat models "chat_history": "Human: Hi! My name is Bob\nAI: Hello Bob! Nice to meet you", } ) > Entering new AgentExecutor chain... <final_answer>Your name is Bob.</final_answer> Since you already told me your name is Bob, I do not need to use any tools to answer the question "what's my name?". I can provide the final answer directly that your name is Bob. > Finished chain. {'input': "what's my name? Only use a tool if needed, otherwise respond with Final Answer", 'chat_history': 'Human: Hi! My name is Bob\nAI: Hello Bob! Nice to meet you', 'output': 'Your name is Bob.'} Custom XML Agents Note: For greater customizability, we recommend checking out LangGraph. Here we provide an example of a custom XML Agent implementation, to give a sense for what create_xml_agent is doing under the hood. from langchain.agents.output_parsers import XMLAgentOutputParser # Logic for going from intermediate steps to a string to pass into model # This is pretty tied to the prompt def convert_intermediate_steps(intermediate_steps): log = "" for action, observation in intermediate_steps: log += ( f"<tool>{action.tool}</tool><tool_input>{action.tool_input}" f"</tool_input><observation>{observation}</observation>" ) return log # Logic for converting tools to string to go in prompt def convert_tools(tools): return "\n".join([f"{tool.name}: {tool.description}" for tool in tools]) Building an agent from a runnable usually involves a few things: Data processing for the intermediate steps. These need to be represented in a way that the language model can recognize them. This should be pretty tightly coupled to the instructions in the prompt The prompt itself The model, complete with stop tokens if needed The output parser - should be in sync with how the prompt specifies things to be formatted. agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: convert_intermediate_steps( x["intermediate_steps"] ), } | prompt.partial(tools=convert_tools(tools)) | llm.bind(stop=["</tool_input>", "</final_answer>"]) | XMLAgentOutputParser() ) agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) agent_executor.invoke({"input": "what is LangChain?"}) > Entering new AgentExecutor chain... <tool>tavily_search_results_json</tool> <tool_input>what is LangChain[{'url': 'https://www.techtarget.com/searchEnterpriseAI/definition/LangChain', 'content': "Everything you need to know\nWhat are the features of LangChain?\nLangChain is made up of the following modules that ensure the multiple components needed to make an effective NLP app can run smoothly:\nWhat are the integrations of LangChain?\nLangChain typically builds applications using integrations with LLM providers and external sources where data can be found and stored. What is synthetic data?\nExamples and use cases for LangChain\nThe LLM-based applications LangChain is capable of building can be applied to multiple advanced use cases within various industries and vertical markets, such as the following:\nReaping the benefits of NLP is a key of why LangChain is important. As the airline giant moves more of its data workloads to the cloud, tools from Intel's Granulate are making platforms such as ...\nThe vendor's new platform, now in beta testing, combines its existing lakehouse with AI to better enable users to manage and ...\n The following steps are required to use this:\nIn this scenario, the language model would be expected to take the two input variables -- the adjective and the content -- and produce a fascinating fact about zebras as its output.\n The goal of LangChain is to link powerful LLMs, such as OpenAI's GPT-3.5 and GPT-4, to an array of external data sources to create and reap the benefits of natural language processing (NLP) applications.\n"}]<final_answer> LangChain is a platform developed by Anthropic that enables users to build NLP applications by linking large language models like GPT-3.5 and GPT-4 to external data sources. It provides modules for managing and integrating different components needed for NLP apps. Some key capabilities and features of LangChain: - Allows linking LLMs to external data sources to create customized NLP apps - Provides modules to manage integration of LLMs, data sources, storage etc. - Enables building conversational AI apps, summarization, search, and other NLP capabilities - Helps users reap benefits of NLP and LLMs for use cases across industries So in summary, it is a platform to build and deploy advanced NLP models by leveraging capabilities of large language models in a more customizable and scalable way. > Finished chain. {'input': 'what is LangChain?', 'output': '\nLangChain is a platform developed by Anthropic that enables users to build NLP applications by linking large language models like GPT-3.5 and GPT-4 to external data sources. It provides modules for managing and integrating different components needed for NLP apps.\n\nSome key capabilities and features of LangChain:\n\n- Allows linking LLMs to external data sources to create customized NLP apps\n- Provides modules to manage integration of LLMs, data sources, storage etc. \n- Enables building conversational AI apps, summarization, search, and other NLP capabilities\n- Helps users reap benefits of NLP and LLMs for use cases across industries\n\nSo in summary, it is a platform to build and deploy advanced NLP models by leveraging capabilities of large language models in a more customizable and scalable way.\n\n'}

https://python.langchain.com/docs/integrations/vectorstores/hologres/

[Hologres](https://www.alibabacloud.com/help/en/hologres/latest/introduction) is a unified real-time data warehousing service developed by Alibaba Cloud. You can use Hologres to write, update, process, and analyze large amounts of data in real time. Hologres supports standard SQL syntax, is compatible with PostgreSQL, and supports most PostgreSQL functions. Hologres supports online analytical processing (OLAP) and ad hoc analysis for up to petabytes of data, and provides high-concurrency and low-latency online data services. This notebook shows how to use functionality related to the `Hologres Proxima` vector database. Click [here](https://www.alibabacloud.com/zh/product/hologres) to fast deploy a Hologres cloud instance. ``` from langchain_community.document_loaders import TextLoaderloader = TextLoader("../../modules/state_of_the_union.txt")documents = loader.load()text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)docs = text_splitter.split_documents(documents)embeddings = OpenAIEmbeddings() ``` Connect to Hologres by setting related ENVIRONMENTS. ``` export PG_HOST={host}export PG_PORT={port} # Optional, default is 80export PG_DATABASE={db_name} # Optional, default is postgresexport PG_USER={username}export PG_PASSWORD={password} ``` ``` import osconnection_string = Hologres.connection_string_from_db_params( host=os.environ.get("PGHOST", "localhost"), port=int(os.environ.get("PGPORT", "80")), database=os.environ.get("PGDATABASE", "postgres"), user=os.environ.get("PGUSER", "postgres"), password=os.environ.get("PGPASSWORD", "postgres"),)vector_db = Hologres.from_documents( docs, embeddings, connection_string=connection_string, table_name="langchain_example_embeddings",) ``` ``` Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. ```

Hologres is a unified real-time data warehousing service developed by Alibaba Cloud. You can use Hologres to write, update, process, and analyze large amounts of data in real time. Hologres supports standard SQL syntax, is compatible with PostgreSQL, and supports most PostgreSQL functions. Hologres supports online analytical processing (OLAP) and ad hoc analysis for up to petabytes of data, and provides high-concurrency and low-latency online data services. This notebook shows how to use functionality related to the Hologres Proxima vector database. Click here to fast deploy a Hologres cloud instance. from langchain_community.document_loaders import TextLoader loader = TextLoader("../../modules/state_of_the_union.txt") documents = loader.load() text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0) docs = text_splitter.split_documents(documents) embeddings = OpenAIEmbeddings() Connect to Hologres by setting related ENVIRONMENTS. export PG_HOST={host} export PG_PORT={port} # Optional, default is 80 export PG_DATABASE={db_name} # Optional, default is postgres export PG_USER={username} export PG_PASSWORD={password} import os connection_string = Hologres.connection_string_from_db_params( host=os.environ.get("PGHOST", "localhost"), port=int(os.environ.get("PGPORT", "80")), database=os.environ.get("PGDATABASE", "postgres"), user=os.environ.get("PGUSER", "postgres"), password=os.environ.get("PGPASSWORD", "postgres"), ) vector_db = Hologres.from_documents( docs, embeddings, connection_string=connection_string, table_name="langchain_example_embeddings", ) Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.

https://python.langchain.com/docs/modules/data_connection/document_loaders/html/

## HTML > [The HyperText Markup Language or HTML](https://en.wikipedia.org/wiki/HTML) is the standard markup language for documents designed to be displayed in a web browser. This covers how to load `HTML` documents into a document format that we can use downstream. ``` from langchain_community.document_loaders import UnstructuredHTMLLoader ``` ``` loader = UnstructuredHTMLLoader("example_data/fake-content.html") ``` ``` [Document(page_content='My First Heading\n\nMy first paragraph.', lookup_str='', metadata={'source': 'example_data/fake-content.html'}, lookup_index=0)] ``` ## Loading HTML with BeautifulSoup4[​](#loading-html-with-beautifulsoup4 "Direct link to Loading HTML with BeautifulSoup4") We can also use `BeautifulSoup4` to load HTML documents using the `BSHTMLLoader`. This will extract the text from the HTML into `page_content`, and the page title as `title` into `metadata`. ``` from langchain_community.document_loaders import BSHTMLLoader ``` ``` loader = BSHTMLLoader("example_data/fake-content.html")data = loader.load()data ``` ``` [Document(page_content='\n\nTest Title\n\n\nMy First Heading\nMy first paragraph.\n\n\n', metadata={'source': 'example_data/fake-content.html', 'title': 'Test Title'})] ``` ## Loading HTML with FireCrawlLoader[​](#loading-html-with-firecrawlloader "Direct link to Loading HTML with FireCrawlLoader") [FireCrawl](https://firecrawl.dev/?ref=langchain) crawls and convert any website into markdown. It crawls all accessible subpages and give you clean markdown and metadata for each. FireCrawl handles complex tasks such as reverse proxies, caching, rate limits, and content blocked by JavaScript. ### Prerequisite[​](#prerequisite "Direct link to Prerequisite") You need to have a FireCrawl API key to use this loader. You can get one by signing up at [FireCrawl](https://firecrawl.dev/?ref=langchainpy). ``` %pip install --upgrade --quiet langchain langchain-community firecrawl-pyfrom langchain_community.document_loaders import FireCrawlLoaderloader = FireCrawlLoader( api_key="YOUR_API_KEY", url="https://firecrawl.dev", mode="crawl")data = loader.load() ``` For more information on how to use FireCrawl, visit [FireCrawl](https://firecrawl.dev/?ref=langchainpy). ## Loading HTML with AzureAIDocumentIntelligenceLoader[​](#loading-html-with-azureaidocumentintelligenceloader "Direct link to Loading HTML with AzureAIDocumentIntelligenceLoader") [Azure AI Document Intelligence](https://aka.ms/doc-intelligence) (formerly known as `Azure Form Recognizer`) is machine-learning based service that extracts texts (including handwriting), tables, document structures (e.g., titles, section headings, etc.) and key-value-pairs from digital or scanned PDFs, images, Office and HTML files. Document Intelligence supports `PDF`, `JPEG/JPG`, `PNG`, `BMP`, `TIFF`, `HEIF`, `DOCX`, `XLSX`, `PPTX` and `HTML`. This [current implementation](https://aka.ms/di-langchain) of a loader using `Document Intelligence` can incorporate content page-wise and turn it into LangChain documents. The default output format is markdown, which can be easily chained with `MarkdownHeaderTextSplitter` for semantic document chunking. You can also use `mode="single"` or `mode="page"` to return pure texts in a single page or document split by page. ### Prerequisite[​](#prerequisite-1 "Direct link to Prerequisite") An Azure AI Document Intelligence resource in one of the 3 preview regions: **East US**, **West US2**, **West Europe** - follow [this document](https://learn.microsoft.com/azure/ai-services/document-intelligence/create-document-intelligence-resource?view=doc-intel-4.0.0) to create one if you don't have. You will be passing `<endpoint>` and `<key>` as parameters to the loader. ``` %pip install --upgrade --quiet langchain langchain-community azure-ai-documentintelligencefrom langchain_community.document_loaders import AzureAIDocumentIntelligenceLoaderfile_path = "<filepath>"endpoint = "<endpoint>"key = "<key>"loader = AzureAIDocumentIntelligenceLoader( api_endpoint=endpoint, api_key=key, file_path=file_path, api_model="prebuilt-layout")documents = loader.load() ```

HTML The HyperText Markup Language or HTML is the standard markup language for documents designed to be displayed in a web browser. This covers how to load HTML documents into a document format that we can use downstream. from langchain_community.document_loaders import UnstructuredHTMLLoader loader = UnstructuredHTMLLoader("example_data/fake-content.html") [Document(page_content='My First Heading\n\nMy first paragraph.', lookup_str='', metadata={'source': 'example_data/fake-content.html'}, lookup_index=0)] Loading HTML with BeautifulSoup4​ We can also use BeautifulSoup4 to load HTML documents using the BSHTMLLoader. This will extract the text from the HTML into page_content, and the page title as title into metadata. from langchain_community.document_loaders import BSHTMLLoader loader = BSHTMLLoader("example_data/fake-content.html") data = loader.load() data [Document(page_content='\n\nTest Title\n\n\nMy First Heading\nMy first paragraph.\n\n\n', metadata={'source': 'example_data/fake-content.html', 'title': 'Test Title'})] Loading HTML with FireCrawlLoader​ FireCrawl crawls and convert any website into markdown. It crawls all accessible subpages and give you clean markdown and metadata for each. FireCrawl handles complex tasks such as reverse proxies, caching, rate limits, and content blocked by JavaScript. Prerequisite​ You need to have a FireCrawl API key to use this loader. You can get one by signing up at FireCrawl. %pip install --upgrade --quiet langchain langchain-community firecrawl-py from langchain_community.document_loaders import FireCrawlLoader loader = FireCrawlLoader( api_key="YOUR_API_KEY", url="https://firecrawl.dev", mode="crawl" ) data = loader.load() For more information on how to use FireCrawl, visit FireCrawl. Loading HTML with AzureAIDocumentIntelligenceLoader​ Azure AI Document Intelligence (formerly known as Azure Form Recognizer) is machine-learning based service that extracts texts (including handwriting), tables, document structures (e.g., titles, section headings, etc.) and key-value-pairs from digital or scanned PDFs, images, Office and HTML files. Document Intelligence supports PDF, JPEG/JPG, PNG, BMP, TIFF, HEIF, DOCX, XLSX, PPTX and HTML. This current implementation of a loader using Document Intelligence can incorporate content page-wise and turn it into LangChain documents. The default output format is markdown, which can be easily chained with MarkdownHeaderTextSplitter for semantic document chunking. You can also use mode="single" or mode="page" to return pure texts in a single page or document split by page. Prerequisite​ An Azure AI Document Intelligence resource in one of the 3 preview regions: East US, West US2, West Europe - follow this document to create one if you don't have. You will be passing <endpoint> and <key> as parameters to the loader. %pip install --upgrade --quiet langchain langchain-community azure-ai-documentintelligence from langchain_community.document_loaders import AzureAIDocumentIntelligenceLoader file_path = "<filepath>" endpoint = "<endpoint>" key = "<key>" loader = AzureAIDocumentIntelligenceLoader( api_endpoint=endpoint, api_key=key, file_path=file_path, api_model="prebuilt-layout" ) documents = loader.load()

https://python.langchain.com/docs/integrations/vectorstores/infinispanvs/

## Infinispan Infinispan is an open-source key-value data grid, it can work as single node as well as distributed. Vector search is supported since release 15.x For more: [Infinispan Home](https://infinispan.org/) ``` # Ensure that all we need is installed# You may want to skip this%pip install sentence-transformers%pip install langchain%pip install langchain_core%pip install langchain_community ``` ## Setup To run this demo we need a running Infinispan instance without authentication and a data file. In the next three cells we’re going to: - download the data file - create the configuration - run Infinispan in docker ``` %%bash#get an archive of newswget https://raw.githubusercontent.com/rigazilla/infinispan-vector/main/bbc_news.csv.gz ``` ``` %%bash#create infinispan configuration fileecho 'infinispan: cache-container: name: default transport: cluster: cluster stack: tcp server: interfaces: interface: name: public inet-address: value: 0.0.0.0 socket-bindings: default-interface: public port-offset: 0 socket-binding: name: default port: 11222 endpoints: endpoint: socket-binding: default rest-connector:' > infinispan-noauth.yaml ``` ``` !docker rm --force infinispanvs-demo!docker run -d --name infinispanvs-demo -v $(pwd):/user-config -p 11222:11222 infinispan/server:15.0 -c /user-config/infinispan-noauth.yaml ``` ## The Code ## Pick up an embedding model[​](#pick-up-an-embedding-model "Direct link to Pick up an embedding model") In this demo we’re using a HuggingFace embedding mode. ``` from langchain.embeddings import HuggingFaceEmbeddingsfrom langchain_core.embeddings import Embeddingsmodel_name = "sentence-transformers/all-MiniLM-L12-v2"hf = HuggingFaceEmbeddings(model_name=model_name) ``` ## Setup Infinispan cache[​](#setup-infinispan-cache "Direct link to Setup Infinispan cache") Infinispan is a very flexible key-value store, it can store raw bits as well as complex data type. User has complete freedom in the datagrid configuration, but for simple data type everything is automatically configured by the python layer. We take advantage of this feature so we can focus on our application. ## Prepare the data[​](#prepare-the-data "Direct link to Prepare the data") In this demo we rely on the default configuration, thus texts, metadatas and vectors in the same cache, but other options are possible: i.e. content can be store somewhere else and vector store could contain only a reference to the actual content. ``` import csvimport gzipimport time# Open the news file and process it as a csvwith gzip.open("bbc_news.csv.gz", "rt", newline="") as csvfile: spamreader = csv.reader(csvfile, delimiter=",", quotechar='"') i = 0 texts = [] metas = [] embeds = [] for row in spamreader: # first and fifth values are joined to form the content # to be processed text = row[0] + "." + row[4] texts.append(text) # Store text and title as metadata meta = {"text": row[4], "title": row[0]} metas.append(meta) i = i + 1 # Change this to change the number of news you want to load if i >= 5000: break ``` ## Populate the vector store ``` # add texts and fill vector dbfrom langchain_community.vectorstores import InfinispanVSispnvs = InfinispanVS.from_texts(texts, hf, metas) ``` ## An helper func that prints the result documents By default InfinispanVS returns the protobuf `ŧext` field in the `Document.page_content` and all the remaining protobuf fields (except the vector) in the `metadata`. This behaviour is configurable via lambda functions at setup. ``` def print_docs(docs): for res, i in zip(docs, range(len(docs))): print("----" + str(i + 1) + "----") print("TITLE: " + res.metadata["title"]) print(res.page_content) ``` ## Try it!!! Below some sample queries ``` docs = ispnvs.similarity_search("European nations", 5)print_docs(docs) ``` ``` print_docs(ispnvs.similarity_search("Milan fashion week begins", 2)) ``` ``` print_docs(ispnvs.similarity_search("Stock market is rising today", 4)) ``` ``` print_docs(ispnvs.similarity_search("Why cats are so viral?", 2)) ``` ``` print_docs(ispnvs.similarity_search("How to stay young", 5)) ``` ``` !docker rm --force infinispanvs-demo ```

Infinispan Infinispan is an open-source key-value data grid, it can work as single node as well as distributed. Vector search is supported since release 15.x For more: Infinispan Home # Ensure that all we need is installed # You may want to skip this %pip install sentence-transformers %pip install langchain %pip install langchain_core %pip install langchain_community Setup To run this demo we need a running Infinispan instance without authentication and a data file. In the next three cells we’re going to: - download the data file - create the configuration - run Infinispan in docker %%bash #get an archive of news wget https://raw.githubusercontent.com/rigazilla/infinispan-vector/main/bbc_news.csv.gz %%bash #create infinispan configuration file echo 'infinispan: cache-container: name: default transport: cluster: cluster stack: tcp server: interfaces: interface: name: public inet-address: value: 0.0.0.0 socket-bindings: default-interface: public port-offset: 0 socket-binding: name: default port: 11222 endpoints: endpoint: socket-binding: default rest-connector: ' > infinispan-noauth.yaml !docker rm --force infinispanvs-demo !docker run -d --name infinispanvs-demo -v $(pwd):/user-config -p 11222:11222 infinispan/server:15.0 -c /user-config/infinispan-noauth.yaml The Code Pick up an embedding model​ In this demo we’re using a HuggingFace embedding mode. from langchain.embeddings import HuggingFaceEmbeddings from langchain_core.embeddings import Embeddings model_name = "sentence-transformers/all-MiniLM-L12-v2" hf = HuggingFaceEmbeddings(model_name=model_name) Setup Infinispan cache​ Infinispan is a very flexible key-value store, it can store raw bits as well as complex data type. User has complete freedom in the datagrid configuration, but for simple data type everything is automatically configured by the python layer. We take advantage of this feature so we can focus on our application. Prepare the data​ In this demo we rely on the default configuration, thus texts, metadatas and vectors in the same cache, but other options are possible: i.e. content can be store somewhere else and vector store could contain only a reference to the actual content. import csv import gzip import time # Open the news file and process it as a csv with gzip.open("bbc_news.csv.gz", "rt", newline="") as csvfile: spamreader = csv.reader(csvfile, delimiter=",", quotechar='"') i = 0 texts = [] metas = [] embeds = [] for row in spamreader: # first and fifth values are joined to form the content # to be processed text = row[0] + "." + row[4] texts.append(text) # Store text and title as metadata meta = {"text": row[4], "title": row[0]} metas.append(meta) i = i + 1 # Change this to change the number of news you want to load if i >= 5000: break Populate the vector store # add texts and fill vector db from langchain_community.vectorstores import InfinispanVS ispnvs = InfinispanVS.from_texts(texts, hf, metas) An helper func that prints the result documents By default InfinispanVS returns the protobuf ŧext field in the Document.page_content and all the remaining protobuf fields (except the vector) in the metadata. This behaviour is configurable via lambda functions at setup. def print_docs(docs): for res, i in zip(docs, range(len(docs))): print("----" + str(i + 1) + "----") print("TITLE: " + res.metadata["title"]) print(res.page_content) Try it!!! Below some sample queries docs = ispnvs.similarity_search("European nations", 5) print_docs(docs) print_docs(ispnvs.similarity_search("Milan fashion week begins", 2)) print_docs(ispnvs.similarity_search("Stock market is rising today", 4)) print_docs(ispnvs.similarity_search("Why cats are so viral?", 2)) print_docs(ispnvs.similarity_search("How to stay young", 5)) !docker rm --force infinispanvs-demo

https://python.langchain.com/docs/modules/data_connection/document_loaders/json/

## JSON > [JSON (JavaScript Object Notation)](https://en.wikipedia.org/wiki/JSON) is an open standard file format and data interchange format that uses human-readable text to store and transmit data objects consisting of attribute–value pairs and arrays (or other serializable values). > [JSON Lines](https://jsonlines.org/) is a file format where each line is a valid JSON value. > The `JSONLoader` uses a specified [jq schema](https://en.wikipedia.org/wiki/Jq_(programming_language)) to parse the JSON files. It uses the `jq` python package. Check this [manual](https://stedolan.github.io/jq/manual/#Basicfilters) for a detailed documentation of the `jq` syntax. ``` from langchain_community.document_loaders import JSONLoader ``` ``` import jsonfrom pathlib import Pathfrom pprint import pprintfile_path='./example_data/facebook_chat.json'data = json.loads(Path(file_path).read_text()) ``` ``` {'image': {'creation_timestamp': 1675549016, 'uri': 'image_of_the_chat.jpg'}, 'is_still_participant': True, 'joinable_mode': {'link': '', 'mode': 1}, 'magic_words': [], 'messages': [{'content': 'Bye!', 'sender_name': 'User 2', 'timestamp_ms': 1675597571851}, {'content': 'Oh no worries! Bye', 'sender_name': 'User 1', 'timestamp_ms': 1675597435669}, {'content': 'No Im sorry it was my mistake, the blue one is not ' 'for sale', 'sender_name': 'User 2', 'timestamp_ms': 1675596277579}, {'content': 'I thought you were selling the blue one!', 'sender_name': 'User 1', 'timestamp_ms': 1675595140251}, {'content': 'Im not interested in this bag. Im interested in the ' 'blue one!', 'sender_name': 'User 1', 'timestamp_ms': 1675595109305}, {'content': 'Here is $129', 'sender_name': 'User 2', 'timestamp_ms': 1675595068468}, {'photos': [{'creation_timestamp': 1675595059, 'uri': 'url_of_some_picture.jpg'}], 'sender_name': 'User 2', 'timestamp_ms': 1675595060730}, {'content': 'Online is at least $100', 'sender_name': 'User 2', 'timestamp_ms': 1675595045152}, {'content': 'How much do you want?', 'sender_name': 'User 1', 'timestamp_ms': 1675594799696}, {'content': 'Goodmorning! $50 is too low.', 'sender_name': 'User 2', 'timestamp_ms': 1675577876645}, {'content': 'Hi! Im interested in your bag. Im offering $50. Let ' 'me know if you are interested. Thanks!', 'sender_name': 'User 1', 'timestamp_ms': 1675549022673}], 'participants': [{'name': 'User 1'}, {'name': 'User 2'}], 'thread_path': 'inbox/User 1 and User 2 chat', 'title': 'User 1 and User 2 chat'} ``` ## Using `JSONLoader`[​](#using-jsonloader "Direct link to using-jsonloader") Suppose we are interested in extracting the values under the `content` field within the `messages` key of the JSON data. This can easily be done through the `JSONLoader` as shown below. ### JSON file[​](#json-file "Direct link to JSON file") ``` loader = JSONLoader( file_path='./example_data/facebook_chat.json', jq_schema='.messages[].content', text_content=False)data = loader.load() ``` ``` [Document(page_content='Bye!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 1}), Document(page_content='Oh no worries! Bye', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 2}), Document(page_content='No Im sorry it was my mistake, the blue one is not for sale', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 3}), Document(page_content='I thought you were selling the blue one!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 4}), Document(page_content='Im not interested in this bag. Im interested in the blue one!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 5}), Document(page_content='Here is $129', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 6}), Document(page_content='', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 7}), Document(page_content='Online is at least $100', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 8}), Document(page_content='How much do you want?', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 9}), Document(page_content='Goodmorning! $50 is too low.', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 10}), Document(page_content='Hi! Im interested in your bag. Im offering $50. Let me know if you are interested. Thanks!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 11})] ``` ### JSON Lines file[​](#json-lines-file "Direct link to JSON Lines file") If you want to load documents from a JSON Lines file, you pass `json_lines=True` and specify `jq_schema` to extract `page_content` from a single JSON object. ``` file_path = './example_data/facebook_chat_messages.jsonl'pprint(Path(file_path).read_text()) ``` ``` ('{"sender_name": "User 2", "timestamp_ms": 1675597571851, "content": "Bye!"}\n' '{"sender_name": "User 1", "timestamp_ms": 1675597435669, "content": "Oh no ' 'worries! Bye"}\n' '{"sender_name": "User 2", "timestamp_ms": 1675596277579, "content": "No Im ' 'sorry it was my mistake, the blue one is not for sale"}\n') ``` ``` loader = JSONLoader( file_path='./example_data/facebook_chat_messages.jsonl', jq_schema='.content', text_content=False, json_lines=True)data = loader.load() ``` ``` [Document(page_content='Bye!', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 1}), Document(page_content='Oh no worries! Bye', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 2}), Document(page_content='No Im sorry it was my mistake, the blue one is not for sale', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 3})] ``` Another option is set `jq_schema='.'` and provide `content_key`: ``` loader = JSONLoader( file_path='./example_data/facebook_chat_messages.jsonl', jq_schema='.', content_key='sender_name', json_lines=True)data = loader.load() ``` ``` [Document(page_content='User 2', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 1}), Document(page_content='User 1', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 2}), Document(page_content='User 2', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 3})] ``` ### JSON file with jq schema `content_key`[​](#json-file-with-jq-schema-content_key "Direct link to json-file-with-jq-schema-content_key") To load documents from a JSON file using the content\_key within the jq schema, set is\_content\_key\_jq\_parsable=True. Ensure that content\_key is compatible and can be parsed using the jq schema. ``` file_path = './sample.json'pprint(Path(file_path).read_text()) ``` ``` {"data": [ {"attributes": { "message": "message1", "tags": [ "tag1"]}, "id": "1"}, {"attributes": { "message": "message2", "tags": [ "tag2"]}, "id": "2"}]} ``` ``` loader = JSONLoader( file_path=file_path, jq_schema=".data[]", content_key=".attributes.message", is_content_key_jq_parsable=True,)data = loader.load() ``` ``` [Document(page_content='message1', metadata={'source': '/path/to/sample.json', 'seq_num': 1}), Document(page_content='message2', metadata={'source': '/path/to/sample.json', 'seq_num': 2})] ``` Generally, we want to include metadata available in the JSON file into the documents that we create from the content. The following demonstrates how metadata can be extracted using the `JSONLoader`. There are some key changes to be noted. In the previous example where we didn't collect the metadata, we managed to directly specify in the schema where the value for the `page_content` can be extracted from. In the current example, we have to tell the loader to iterate over the records in the `messages` field. The jq\_schema then has to be: This allows us to pass the records (dict) into the `metadata_func` that has to be implemented. The `metadata_func` is responsible for identifying which pieces of information in the record should be included in the metadata stored in the final `Document` object. Additionally, we now have to explicitly specify in the loader, via the `content_key` argument, the key from the record where the value for the `page_content` needs to be extracted from. ``` # Define the metadata extraction function.def metadata_func(record: dict, metadata: dict) -> dict: metadata["sender_name"] = record.get("sender_name") metadata["timestamp_ms"] = record.get("timestamp_ms") return metadataloader = JSONLoader( file_path='./example_data/facebook_chat.json', jq_schema='.messages[]', content_key="content", metadata_func=metadata_func)data = loader.load() ``` ``` [Document(page_content='Bye!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 1, 'sender_name': 'User 2', 'timestamp_ms': 1675597571851}), Document(page_content='Oh no worries! Bye', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 2, 'sender_name': 'User 1', 'timestamp_ms': 1675597435669}), Document(page_content='No Im sorry it was my mistake, the blue one is not for sale', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 3, 'sender_name': 'User 2', 'timestamp_ms': 1675596277579}), Document(page_content='I thought you were selling the blue one!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 4, 'sender_name': 'User 1', 'timestamp_ms': 1675595140251}), Document(page_content='Im not interested in this bag. Im interested in the blue one!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 5, 'sender_name': 'User 1', 'timestamp_ms': 1675595109305}), Document(page_content='Here is $129', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 6, 'sender_name': 'User 2', 'timestamp_ms': 1675595068468}), Document(page_content='', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 7, 'sender_name': 'User 2', 'timestamp_ms': 1675595060730}), Document(page_content='Online is at least $100', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 8, 'sender_name': 'User 2', 'timestamp_ms': 1675595045152}), Document(page_content='How much do you want?', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 9, 'sender_name': 'User 1', 'timestamp_ms': 1675594799696}), Document(page_content='Goodmorning! $50 is too low.', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 10, 'sender_name': 'User 2', 'timestamp_ms': 1675577876645}), Document(page_content='Hi! Im interested in your bag. Im offering $50. Let me know if you are interested. Thanks!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 11, 'sender_name': 'User 1', 'timestamp_ms': 1675549022673})] ``` Now, you will see that the documents contain the metadata associated with the content we extracted. As shown above, the `metadata_func` accepts the default metadata generated by the `JSONLoader`. This allows full control to the user with respect to how the metadata is formatted. For example, the default metadata contains the `source` and the `seq_num` keys. However, it is possible that the JSON data contain these keys as well. The user can then exploit the `metadata_func` to rename the default keys and use the ones from the JSON data. The example below shows how we can modify the `source` to only contain information of the file source relative to the `langchain` directory. ``` # Define the metadata extraction function.def metadata_func(record: dict, metadata: dict) -> dict: metadata["sender_name"] = record.get("sender_name") metadata["timestamp_ms"] = record.get("timestamp_ms") if "source" in metadata: source = metadata["source"].split("/") source = source[source.index("langchain"):] metadata["source"] = "/".join(source) return metadataloader = JSONLoader( file_path='./example_data/facebook_chat.json', jq_schema='.messages[]', content_key="content", metadata_func=metadata_func)data = loader.load() ``` ``` [Document(page_content='Bye!', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 1, 'sender_name': 'User 2', 'timestamp_ms': 1675597571851}), Document(page_content='Oh no worries! Bye', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 2, 'sender_name': 'User 1', 'timestamp_ms': 1675597435669}), Document(page_content='No Im sorry it was my mistake, the blue one is not for sale', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 3, 'sender_name': 'User 2', 'timestamp_ms': 1675596277579}), Document(page_content='I thought you were selling the blue one!', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 4, 'sender_name': 'User 1', 'timestamp_ms': 1675595140251}), Document(page_content='Im not interested in this bag. Im interested in the blue one!', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 5, 'sender_name': 'User 1', 'timestamp_ms': 1675595109305}), Document(page_content='Here is $129', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 6, 'sender_name': 'User 2', 'timestamp_ms': 1675595068468}), Document(page_content='', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 7, 'sender_name': 'User 2', 'timestamp_ms': 1675595060730}), Document(page_content='Online is at least $100', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 8, 'sender_name': 'User 2', 'timestamp_ms': 1675595045152}), Document(page_content='How much do you want?', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 9, 'sender_name': 'User 1', 'timestamp_ms': 1675594799696}), Document(page_content='Goodmorning! $50 is too low.', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 10, 'sender_name': 'User 2', 'timestamp_ms': 1675577876645}), Document(page_content='Hi! Im interested in your bag. Im offering $50. Let me know if you are interested. Thanks!', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 11, 'sender_name': 'User 1', 'timestamp_ms': 1675549022673})] ``` ## Common JSON structures with jq schema[​](#common-json-structures-with-jq-schema "Direct link to Common JSON structures with jq schema") The list below provides a reference to the possible `jq_schema` the user can use to extract content from the JSON data depending on the structure. ``` JSON -> [{"text": ...}, {"text": ...}, {"text": ...}]jq_schema -> ".[].text"JSON -> {"key": [{"text": ...}, {"text": ...}, {"text": ...}]}jq_schema -> ".key[].text"JSON -> ["...", "...", "..."]jq_schema -> ".[]" ```

JSON JSON (JavaScript Object Notation) is an open standard file format and data interchange format that uses human-readable text to store and transmit data objects consisting of attribute–value pairs and arrays (or other serializable values). JSON Lines is a file format where each line is a valid JSON value. The JSONLoader uses a specified jq schema to parse the JSON files. It uses the jq python package. Check this manual for a detailed documentation of the jq syntax. from langchain_community.document_loaders import JSONLoader import json from pathlib import Path from pprint import pprint file_path='./example_data/facebook_chat.json' data = json.loads(Path(file_path).read_text()) {'image': {'creation_timestamp': 1675549016, 'uri': 'image_of_the_chat.jpg'}, 'is_still_participant': True, 'joinable_mode': {'link': '', 'mode': 1}, 'magic_words': [], 'messages': [{'content': 'Bye!', 'sender_name': 'User 2', 'timestamp_ms': 1675597571851}, {'content': 'Oh no worries! Bye', 'sender_name': 'User 1', 'timestamp_ms': 1675597435669}, {'content': 'No Im sorry it was my mistake, the blue one is not ' 'for sale', 'sender_name': 'User 2', 'timestamp_ms': 1675596277579}, {'content': 'I thought you were selling the blue one!', 'sender_name': 'User 1', 'timestamp_ms': 1675595140251}, {'content': 'Im not interested in this bag. Im interested in the ' 'blue one!', 'sender_name': 'User 1', 'timestamp_ms': 1675595109305}, {'content': 'Here is $129', 'sender_name': 'User 2', 'timestamp_ms': 1675595068468}, {'photos': [{'creation_timestamp': 1675595059, 'uri': 'url_of_some_picture.jpg'}], 'sender_name': 'User 2', 'timestamp_ms': 1675595060730}, {'content': 'Online is at least $100', 'sender_name': 'User 2', 'timestamp_ms': 1675595045152}, {'content': 'How much do you want?', 'sender_name': 'User 1', 'timestamp_ms': 1675594799696}, {'content': 'Goodmorning! $50 is too low.', 'sender_name': 'User 2', 'timestamp_ms': 1675577876645}, {'content': 'Hi! Im interested in your bag. Im offering $50. Let ' 'me know if you are interested. Thanks!', 'sender_name': 'User 1', 'timestamp_ms': 1675549022673}], 'participants': [{'name': 'User 1'}, {'name': 'User 2'}], 'thread_path': 'inbox/User 1 and User 2 chat', 'title': 'User 1 and User 2 chat'} Using JSONLoader​ Suppose we are interested in extracting the values under the content field within the messages key of the JSON data. This can easily be done through the JSONLoader as shown below. JSON file​ loader = JSONLoader( file_path='./example_data/facebook_chat.json', jq_schema='.messages[].content', text_content=False) data = loader.load() [Document(page_content='Bye!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 1}), Document(page_content='Oh no worries! Bye', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 2}), Document(page_content='No Im sorry it was my mistake, the blue one is not for sale', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 3}), Document(page_content='I thought you were selling the blue one!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 4}), Document(page_content='Im not interested in this bag. Im interested in the blue one!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 5}), Document(page_content='Here is $129', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 6}), Document(page_content='', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 7}), Document(page_content='Online is at least $100', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 8}), Document(page_content='How much do you want?', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 9}), Document(page_content='Goodmorning! $50 is too low.', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 10}), Document(page_content='Hi! Im interested in your bag. Im offering $50. Let me know if you are interested. Thanks!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 11})] JSON Lines file​ If you want to load documents from a JSON Lines file, you pass json_lines=True and specify jq_schema to extract page_content from a single JSON object. file_path = './example_data/facebook_chat_messages.jsonl' pprint(Path(file_path).read_text()) ('{"sender_name": "User 2", "timestamp_ms": 1675597571851, "content": "Bye!"}\n' '{"sender_name": "User 1", "timestamp_ms": 1675597435669, "content": "Oh no ' 'worries! Bye"}\n' '{"sender_name": "User 2", "timestamp_ms": 1675596277579, "content": "No Im ' 'sorry it was my mistake, the blue one is not for sale"}\n') loader = JSONLoader( file_path='./example_data/facebook_chat_messages.jsonl', jq_schema='.content', text_content=False, json_lines=True) data = loader.load() [Document(page_content='Bye!', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 1}), Document(page_content='Oh no worries! Bye', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 2}), Document(page_content='No Im sorry it was my mistake, the blue one is not for sale', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 3})] Another option is set jq_schema='.' and provide content_key: loader = JSONLoader( file_path='./example_data/facebook_chat_messages.jsonl', jq_schema='.', content_key='sender_name', json_lines=True) data = loader.load() [Document(page_content='User 2', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 1}), Document(page_content='User 1', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 2}), Document(page_content='User 2', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 3})] JSON file with jq schema content_key​ To load documents from a JSON file using the content_key within the jq schema, set is_content_key_jq_parsable=True. Ensure that content_key is compatible and can be parsed using the jq schema. file_path = './sample.json' pprint(Path(file_path).read_text()) {"data": [ {"attributes": { "message": "message1", "tags": [ "tag1"]}, "id": "1"}, {"attributes": { "message": "message2", "tags": [ "tag2"]}, "id": "2"}]} loader = JSONLoader( file_path=file_path, jq_schema=".data[]", content_key=".attributes.message", is_content_key_jq_parsable=True, ) data = loader.load() [Document(page_content='message1', metadata={'source': '/path/to/sample.json', 'seq_num': 1}), Document(page_content='message2', metadata={'source': '/path/to/sample.json', 'seq_num': 2})] Generally, we want to include metadata available in the JSON file into the documents that we create from the content. The following demonstrates how metadata can be extracted using the JSONLoader. There are some key changes to be noted. In the previous example where we didn't collect the metadata, we managed to directly specify in the schema where the value for the page_content can be extracted from. In the current example, we have to tell the loader to iterate over the records in the messages field. The jq_schema then has to be: This allows us to pass the records (dict) into the metadata_func that has to be implemented. The metadata_func is responsible for identifying which pieces of information in the record should be included in the metadata stored in the final Document object. Additionally, we now have to explicitly specify in the loader, via the content_key argument, the key from the record where the value for the page_content needs to be extracted from. # Define the metadata extraction function. def metadata_func(record: dict, metadata: dict) -> dict: metadata["sender_name"] = record.get("sender_name") metadata["timestamp_ms"] = record.get("timestamp_ms") return metadata loader = JSONLoader( file_path='./example_data/facebook_chat.json', jq_schema='.messages[]', content_key="content", metadata_func=metadata_func ) data = loader.load() [Document(page_content='Bye!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 1, 'sender_name': 'User 2', 'timestamp_ms': 1675597571851}), Document(page_content='Oh no worries! Bye', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 2, 'sender_name': 'User 1', 'timestamp_ms': 1675597435669}), Document(page_content='No Im sorry it was my mistake, the blue one is not for sale', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 3, 'sender_name': 'User 2', 'timestamp_ms': 1675596277579}), Document(page_content='I thought you were selling the blue one!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 4, 'sender_name': 'User 1', 'timestamp_ms': 1675595140251}), Document(page_content='Im not interested in this bag. Im interested in the blue one!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 5, 'sender_name': 'User 1', 'timestamp_ms': 1675595109305}), Document(page_content='Here is $129', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 6, 'sender_name': 'User 2', 'timestamp_ms': 1675595068468}), Document(page_content='', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 7, 'sender_name': 'User 2', 'timestamp_ms': 1675595060730}), Document(page_content='Online is at least $100', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 8, 'sender_name': 'User 2', 'timestamp_ms': 1675595045152}), Document(page_content='How much do you want?', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 9, 'sender_name': 'User 1', 'timestamp_ms': 1675594799696}), Document(page_content='Goodmorning! $50 is too low.', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 10, 'sender_name': 'User 2', 'timestamp_ms': 1675577876645}), Document(page_content='Hi! Im interested in your bag. Im offering $50. Let me know if you are interested. Thanks!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 11, 'sender_name': 'User 1', 'timestamp_ms': 1675549022673})] Now, you will see that the documents contain the metadata associated with the content we extracted. As shown above, the metadata_func accepts the default metadata generated by the JSONLoader. This allows full control to the user with respect to how the metadata is formatted. For example, the default metadata contains the source and the seq_num keys. However, it is possible that the JSON data contain these keys as well. The user can then exploit the metadata_func to rename the default keys and use the ones from the JSON data. The example below shows how we can modify the source to only contain information of the file source relative to the langchain directory. # Define the metadata extraction function. def metadata_func(record: dict, metadata: dict) -> dict: metadata["sender_name"] = record.get("sender_name") metadata["timestamp_ms"] = record.get("timestamp_ms") if "source" in metadata: source = metadata["source"].split("/") source = source[source.index("langchain"):] metadata["source"] = "/".join(source) return metadata loader = JSONLoader( file_path='./example_data/facebook_chat.json', jq_schema='.messages[]', content_key="content", metadata_func=metadata_func ) data = loader.load() [Document(page_content='Bye!', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 1, 'sender_name': 'User 2', 'timestamp_ms': 1675597571851}), Document(page_content='Oh no worries! Bye', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 2, 'sender_name': 'User 1', 'timestamp_ms': 1675597435669}), Document(page_content='No Im sorry it was my mistake, the blue one is not for sale', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 3, 'sender_name': 'User 2', 'timestamp_ms': 1675596277579}), Document(page_content='I thought you were selling the blue one!', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 4, 'sender_name': 'User 1', 'timestamp_ms': 1675595140251}), Document(page_content='Im not interested in this bag. Im interested in the blue one!', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 5, 'sender_name': 'User 1', 'timestamp_ms': 1675595109305}), Document(page_content='Here is $129', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 6, 'sender_name': 'User 2', 'timestamp_ms': 1675595068468}), Document(page_content='', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 7, 'sender_name': 'User 2', 'timestamp_ms': 1675595060730}), Document(page_content='Online is at least $100', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 8, 'sender_name': 'User 2', 'timestamp_ms': 1675595045152}), Document(page_content='How much do you want?', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 9, 'sender_name': 'User 1', 'timestamp_ms': 1675594799696}), Document(page_content='Goodmorning! $50 is too low.', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 10, 'sender_name': 'User 2', 'timestamp_ms': 1675577876645}), Document(page_content='Hi! Im interested in your bag. Im offering $50. Let me know if you are interested. Thanks!', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 11, 'sender_name': 'User 1', 'timestamp_ms': 1675549022673})] Common JSON structures with jq schema​ The list below provides a reference to the possible jq_schema the user can use to extract content from the JSON data depending on the structure. JSON -> [{"text": ...}, {"text": ...}, {"text": ...}] jq_schema -> ".[].text" JSON -> {"key": [{"text": ...}, {"text": ...}, {"text": ...}]} jq_schema -> ".key[].text" JSON -> ["...", "...", "..."] jq_schema -> ".[]"

https://python.langchain.com/docs/modules/agents/agent_types/tool_calling/

## Tool calling agent [Tool calling](https://python.langchain.com/docs/modules/model_io/chat/function_calling/) allows a model to detect when one or more tools should be called and respond with the inputs that should be passed to those tools. In an API call, you can describe tools and have the model intelligently choose to output a structured object like JSON containing arguments to call these tools. The goal of tools APIs is to more reliably return valid and useful tool calls than what can be done using a generic text completion or chat API. We can take advantage of this structured output, combined with the fact that you can bind multiple tools to a [tool calling chat model](https://python.langchain.com/docs/integrations/chat/) and allow the model to choose which one to call, to create an agent that repeatedly calls tools and receives results until a query is resolved. This is a more generalized version of the [OpenAI tools agent](https://python.langchain.com/docs/modules/agents/agent_types/openai_tools/), which was designed for OpenAI’s specific style of tool calling. It uses LangChain’s ToolCall interface to support a wider range of provider implementations, such as [Anthropic](https://python.langchain.com/docs/integrations/chat/anthropic/), [Google Gemini](https://python.langchain.com/docs/integrations/chat/google_vertex_ai_palm/), and [Mistral](https://python.langchain.com/docs/integrations/chat/mistralai/) in addition to [OpenAI](https://python.langchain.com/docs/integrations/chat/openai/). ## Setup[​](#setup "Direct link to Setup") Any models that support tool calling can be used in this agent. You can see which models support tool calling [here](https://python.langchain.com/docs/integrations/chat/) This demo uses [Tavily](https://app.tavily.com/), but you can also swap in any other [built-in tool](https://python.langchain.com/docs/integrations/tools/) or add [custom tools](https://python.langchain.com/docs/modules/tools/custom_tools/). You’ll need to sign up for an API key and set it as `process.env.TAVILY_API_KEY`. * OpenAI * Anthropic * Google * FireworksAI * MistralAI * TogetherAI ##### Install dependencies ``` pip install -qU langchain-openai ``` ##### Set environment variables ``` import getpassimport osos.environ["OPENAI_API_KEY"] = getpass.getpass() ``` ``` from langchain_openai import ChatOpenAIllm = ChatOpenAI(model="gpt-3.5-turbo-0125") ``` We will first create a tool that can search the web: ``` from langchain.agents import AgentExecutor, create_tool_calling_agentfrom langchain_community.tools.tavily_search import TavilySearchResultsfrom langchain_core.prompts import ChatPromptTemplatetools = [TavilySearchResults(max_results=1)] ``` ## Create Agent[​](#create-agent "Direct link to Create Agent") Next, let’s initialize our tool calling agent: ``` prompt = ChatPromptTemplate.from_messages( [ ( "system", "You are a helpful assistant. Make sure to use the tavily_search_results_json tool for information.", ), ("placeholder", "{chat_history}"), ("human", "{input}"), ("placeholder", "{agent_scratchpad}"), ])# Construct the Tools agentagent = create_tool_calling_agent(llm, tools, prompt) ``` ## Run Agent[​](#run-agent "Direct link to Run Agent") Now, let’s initialize the executor that will run our agent and invoke it! ``` # Create an agent executor by passing in the agent and toolsagent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)agent_executor.invoke({"input": "what is LangChain?"}) ``` ``` > Entering new AgentExecutor chain...Invoking: `tavily_search_results_json` with `{'query': 'LangChain'}`responded: [{'id': 'toolu_01QxrrT9srzkYCNyEZMDhGeg', 'input': {'query': 'LangChain'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}][{'url': 'https://github.com/langchain-ai/langchain', 'content': 'About\n⚡ Building applications with LLMs through composability ⚡\nResources\nLicense\nCode of conduct\nSecurity policy\nStars\nWatchers\nForks\nReleases\n291\nPackages\n0\nUsed by 39k\nContributors\n1,848\nLanguages\nFooter\nFooter navigation Latest commit\nGit stats\nFiles\nREADME.md\n🦜️🔗 LangChain\n⚡ Building applications with LLMs through composability ⚡\nLooking for the JS/TS library? ⚡ Building applications with LLMs through composability ⚡\nLicense\nlangchain-ai/langchain\nName already in use\nUse Git or checkout with SVN using the web URL.\n 📖 Documentation\nPlease see here for full documentation, which includes:\n💁 Contributing\nAs an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.\n What can you build with LangChain?\n❓ Retrieval augmented generation\n💬 Analyzing structured data\n🤖 Chatbots\nAnd much more!'}]LangChain is an open-source Python library that helps developers build applications with large language models (LLMs) through composability. Some key features of LangChain include:- Retrieval augmented generation - Allowing LLMs to retrieve and utilize external data sources when generating outputs.- Analyzing structured data - Tools for working with structured data like databases, APIs, PDFs, etc. and allowing LLMs to reason over this data.- Building chatbots and agents - Frameworks for building conversational AI applications.- Composability - LangChain allows you to chain together different LLM capabilities and data sources in a modular and reusable way.The library aims to make it easier to build real-world applications that leverage the power of large language models in a scalable and robust way. It provides abstractions and primitives for working with LLMs from different providers like OpenAI, Anthropic, Cohere, etc. LangChain is open-source and has an active community contributing new features and improvements.> Finished chain. ``` ``` /Users/bagatur/langchain/libs/partners/anthropic/langchain_anthropic/chat_models.py:347: UserWarning: stream: Tool use is not yet supported in streaming mode. warnings.warn("stream: Tool use is not yet supported in streaming mode.")/Users/bagatur/langchain/libs/partners/anthropic/langchain_anthropic/chat_models.py:347: UserWarning: stream: Tool use is not yet supported in streaming mode. warnings.warn("stream: Tool use is not yet supported in streaming mode.") ``` ``` {'input': 'what is LangChain?', 'output': 'LangChain is an open-source Python library that helps developers build applications with large language models (LLMs) through composability. Some key features of LangChain include:\n\n- Retrieval augmented generation - Allowing LLMs to retrieve and utilize external data sources when generating outputs.\n\n- Analyzing structured data - Tools for working with structured data like databases, APIs, PDFs, etc. and allowing LLMs to reason over this data.\n\n- Building chatbots and agents - Frameworks for building conversational AI applications.\n\n- Composability - LangChain allows you to chain together different LLM capabilities and data sources in a modular and reusable way.\n\nThe library aims to make it easier to build real-world applications that leverage the power of large language models in a scalable and robust way. It provides abstractions and primitives for working with LLMs from different providers like OpenAI, Anthropic, Cohere, etc. LangChain is open-source and has an active community contributing new features and improvements.'} ``` ## Using with chat history[​](#using-with-chat-history "Direct link to Using with chat history") This type of agent can optionally take chat messages representing previous conversation turns. It can use that previous history to respond conversationally. For more details, see [this section of the agent quickstart](https://python.langchain.com/docs/modules/agents/quick_start/#adding-in-memory). ``` from langchain_core.messages import AIMessage, HumanMessageagent_executor.invoke( { "input": "what's my name? Don't use tools to look this up unless you NEED to", "chat_history": [ HumanMessage(content="hi! my name is bob"), AIMessage(content="Hello Bob! How can I assist you today?"), ], }) ``` ``` > Entering new AgentExecutor chain...Based on what you told me, your name is Bob. I don't need to use any tools to look that up since you directly provided your name.> Finished chain. ``` ``` /Users/bagatur/langchain/libs/partners/anthropic/langchain_anthropic/chat_models.py:347: UserWarning: stream: Tool use is not yet supported in streaming mode. warnings.warn("stream: Tool use is not yet supported in streaming mode.") ``` ``` {'input': "what's my name? Don't use tools to look this up unless you NEED to", 'chat_history': [HumanMessage(content='hi! my name is bob'), AIMessage(content='Hello Bob! How can I assist you today?')], 'output': "Based on what you told me, your name is Bob. I don't need to use any tools to look that up since you directly provided your name."} ```

Tool calling agent Tool calling allows a model to detect when one or more tools should be called and respond with the inputs that should be passed to those tools. In an API call, you can describe tools and have the model intelligently choose to output a structured object like JSON containing arguments to call these tools. The goal of tools APIs is to more reliably return valid and useful tool calls than what can be done using a generic text completion or chat API. We can take advantage of this structured output, combined with the fact that you can bind multiple tools to a tool calling chat model and allow the model to choose which one to call, to create an agent that repeatedly calls tools and receives results until a query is resolved. This is a more generalized version of the OpenAI tools agent, which was designed for OpenAI’s specific style of tool calling. It uses LangChain’s ToolCall interface to support a wider range of provider implementations, such as Anthropic, Google Gemini, and Mistral in addition to OpenAI. Setup​ Any models that support tool calling can be used in this agent. You can see which models support tool calling here This demo uses Tavily, but you can also swap in any other built-in tool or add custom tools. You’ll need to sign up for an API key and set it as process.env.TAVILY_API_KEY. OpenAI Anthropic Google FireworksAI MistralAI TogetherAI Install dependencies pip install -qU langchain-openai Set environment variables import getpass import os os.environ["OPENAI_API_KEY"] = getpass.getpass() from langchain_openai import ChatOpenAI llm = ChatOpenAI(model="gpt-3.5-turbo-0125") We will first create a tool that can search the web: from langchain.agents import AgentExecutor, create_tool_calling_agent from langchain_community.tools.tavily_search import TavilySearchResults from langchain_core.prompts import ChatPromptTemplate tools = [TavilySearchResults(max_results=1)] Create Agent​ Next, let’s initialize our tool calling agent: prompt = ChatPromptTemplate.from_messages( [ ( "system", "You are a helpful assistant. Make sure to use the tavily_search_results_json tool for information.", ), ("placeholder", "{chat_history}"), ("human", "{input}"), ("placeholder", "{agent_scratchpad}"), ] ) # Construct the Tools agent agent = create_tool_calling_agent(llm, tools, prompt) Run Agent​ Now, let’s initialize the executor that will run our agent and invoke it! # Create an agent executor by passing in the agent and tools agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) agent_executor.invoke({"input": "what is LangChain?"}) > Entering new AgentExecutor chain... Invoking: `tavily_search_results_json` with `{'query': 'LangChain'}` responded: [{'id': 'toolu_01QxrrT9srzkYCNyEZMDhGeg', 'input': {'query': 'LangChain'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}] [{'url': 'https://github.com/langchain-ai/langchain', 'content': 'About\n⚡ Building applications with LLMs through composability ⚡\nResources\nLicense\nCode of conduct\nSecurity policy\nStars\nWatchers\nForks\nReleases\n291\nPackages\n0\nUsed by 39k\nContributors\n1,848\nLanguages\nFooter\nFooter navigation Latest commit\nGit stats\nFiles\nREADME.md\n🦜️🔗 LangChain\n⚡ Building applications with LLMs through composability ⚡\nLooking for the JS/TS library? ⚡ Building applications with LLMs through composability ⚡\nLicense\nlangchain-ai/langchain\nName already in use\nUse Git or checkout with SVN using the web URL.\n 📖 Documentation\nPlease see here for full documentation, which includes:\n💁 Contributing\nAs an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.\n What can you build with LangChain?\n❓ Retrieval augmented generation\n💬 Analyzing structured data\n🤖 Chatbots\nAnd much more!'}]LangChain is an open-source Python library that helps developers build applications with large language models (LLMs) through composability. Some key features of LangChain include: - Retrieval augmented generation - Allowing LLMs to retrieve and utilize external data sources when generating outputs. - Analyzing structured data - Tools for working with structured data like databases, APIs, PDFs, etc. and allowing LLMs to reason over this data. - Building chatbots and agents - Frameworks for building conversational AI applications. - Composability - LangChain allows you to chain together different LLM capabilities and data sources in a modular and reusable way. The library aims to make it easier to build real-world applications that leverage the power of large language models in a scalable and robust way. It provides abstractions and primitives for working with LLMs from different providers like OpenAI, Anthropic, Cohere, etc. LangChain is open-source and has an active community contributing new features and improvements. > Finished chain. /Users/bagatur/langchain/libs/partners/anthropic/langchain_anthropic/chat_models.py:347: UserWarning: stream: Tool use is not yet supported in streaming mode. warnings.warn("stream: Tool use is not yet supported in streaming mode.") /Users/bagatur/langchain/libs/partners/anthropic/langchain_anthropic/chat_models.py:347: UserWarning: stream: Tool use is not yet supported in streaming mode. warnings.warn("stream: Tool use is not yet supported in streaming mode.") {'input': 'what is LangChain?', 'output': 'LangChain is an open-source Python library that helps developers build applications with large language models (LLMs) through composability. Some key features of LangChain include:\n\n- Retrieval augmented generation - Allowing LLMs to retrieve and utilize external data sources when generating outputs.\n\n- Analyzing structured data - Tools for working with structured data like databases, APIs, PDFs, etc. and allowing LLMs to reason over this data.\n\n- Building chatbots and agents - Frameworks for building conversational AI applications.\n\n- Composability - LangChain allows you to chain together different LLM capabilities and data sources in a modular and reusable way.\n\nThe library aims to make it easier to build real-world applications that leverage the power of large language models in a scalable and robust way. It provides abstractions and primitives for working with LLMs from different providers like OpenAI, Anthropic, Cohere, etc. LangChain is open-source and has an active community contributing new features and improvements.'} Using with chat history​ This type of agent can optionally take chat messages representing previous conversation turns. It can use that previous history to respond conversationally. For more details, see this section of the agent quickstart. from langchain_core.messages import AIMessage, HumanMessage agent_executor.invoke( { "input": "what's my name? Don't use tools to look this up unless you NEED to", "chat_history": [ HumanMessage(content="hi! my name is bob"), AIMessage(content="Hello Bob! How can I assist you today?"), ], } ) > Entering new AgentExecutor chain... Based on what you told me, your name is Bob. I don't need to use any tools to look that up since you directly provided your name. > Finished chain. /Users/bagatur/langchain/libs/partners/anthropic/langchain_anthropic/chat_models.py:347: UserWarning: stream: Tool use is not yet supported in streaming mode. warnings.warn("stream: Tool use is not yet supported in streaming mode.") {'input': "what's my name? Don't use tools to look this up unless you NEED to", 'chat_history': [HumanMessage(content='hi! my name is bob'), AIMessage(content='Hello Bob! How can I assist you today?')], 'output': "Based on what you told me, your name is Bob. I don't need to use any tools to look that up since you directly provided your name."}

https://python.langchain.com/docs/modules/data_connection/document_loaders/markdown/

This covers how to load `Markdown` documents into a document format that we can use downstream. ``` [Document(page_content="ð\x9f¦\x9cï¸\x8fð\x9f”\x97 LangChain\n\nâ\x9a¡ Building applications with LLMs through composability â\x9a¡\n\nLooking for the JS/TS version? Check out LangChain.js.\n\nProduction Support: As you move your LangChains into production, we'd love to offer more comprehensive support.\nPlease fill out this form and we'll set up a dedicated support Slack channel.\n\nQuick Install\n\npip install langchain\nor\nconda install langchain -c conda-forge\n\nð\x9f¤” What is this?\n\nLarge language models (LLMs) are emerging as a transformative technology, enabling developers to build applications that they previously could not. However, using these LLMs in isolation is often insufficient for creating a truly powerful app - the real power comes when you can combine them with other sources of computation or knowledge.\n\nThis library aims to assist in the development of those types of applications. Common examples of these applications include:\n\nâ\x9d“ Question Answering over specific documents\n\nDocumentation\n\nEnd-to-end Example: Question Answering over Notion Database\n\nð\x9f’¬ Chatbots\n\nDocumentation\n\nEnd-to-end Example: Chat-LangChain\n\nð\x9f¤\x96 Agents\n\nDocumentation\n\nEnd-to-end Example: GPT+WolframAlpha\n\nð\x9f“\x96 Documentation\n\nPlease see here for full documentation on:\n\nGetting started (installation, setting up the environment, simple examples)\n\nHow-To examples (demos, integrations, helper functions)\n\nReference (full API docs)\n\nResources (high-level explanation of core concepts)\n\nð\x9f\x9a\x80 What can this help with?\n\nThere are six main areas that LangChain is designed to help with.\nThese are, in increasing order of complexity:\n\nð\x9f“\x83 LLMs and Prompts:\n\nThis includes prompt management, prompt optimization, a generic interface for all LLMs, and common utilities for working with LLMs.\n\nð\x9f”\x97 Chains:\n\nChains go beyond a single LLM call and involve sequences of calls (whether to an LLM or a different utility). LangChain provides a standard interface for chains, lots of integrations with other tools, and end-to-end chains for common applications.\n\nð\x9f“\x9a Data Augmented Generation:\n\nData Augmented Generation involves specific types of chains that first interact with an external data source to fetch data for use in the generation step. Examples include summarization of long pieces of text and question/answering over specific data sources.\n\nð\x9f¤\x96 Agents:\n\nAgents involve an LLM making decisions about which Actions to take, taking that Action, seeing an Observation, and repeating that until done. LangChain provides a standard interface for agents, a selection of agents to choose from, and examples of end-to-end agents.\n\nð\x9f§\xa0 Memory:\n\nMemory refers to persisting state between calls of a chain/agent. LangChain provides a standard interface for memory, a collection of memory implementations, and examples of chains/agents that use memory.\n\nð\x9f§\x90 Evaluation:\n\n[BETA] Generative models are notoriously hard to evaluate with traditional metrics. One new way of evaluating them is using language models themselves to do the evaluation. LangChain provides some prompts/chains for assisting in this.\n\nFor more information on these concepts, please see our full documentation.\n\nð\x9f’\x81 Contributing\n\nAs an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.\n\nFor detailed information on how to contribute, see here.", metadata={'source': '../../../../../README.md'})] ``` Under the hood, Unstructured creates different "elements" for different chunks of text. By default we combine those together, but you can easily keep that separation by specifying `mode="elements"`.

This covers how to load Markdown documents into a document format that we can use downstream. [Document(page_content="ð\x9f¦\x9cï¸\x8fð\x9f”\x97 LangChain\n\nâ\x9a¡ Building applications with LLMs through composability â\x9a¡\n\nLooking for the JS/TS version? Check out LangChain.js.\n\nProduction Support: As you move your LangChains into production, we'd love to offer more comprehensive support.\nPlease fill out this form and we'll set up a dedicated support Slack channel.\n\nQuick Install\n\npip install langchain\nor\nconda install langchain -c conda-forge\n\nð\x9f¤” What is this?\n\nLarge language models (LLMs) are emerging as a transformative technology, enabling developers to build applications that they previously could not. However, using these LLMs in isolation is often insufficient for creating a truly powerful app - the real power comes when you can combine them with other sources of computation or knowledge.\n\nThis library aims to assist in the development of those types of applications. Common examples of these applications include:\n\nâ\x9d“ Question Answering over specific documents\n\nDocumentation\n\nEnd-to-end Example: Question Answering over Notion Database\n\nð\x9f’¬ Chatbots\n\nDocumentation\n\nEnd-to-end Example: Chat-LangChain\n\nð\x9f¤\x96 Agents\n\nDocumentation\n\nEnd-to-end Example: GPT+WolframAlpha\n\nð\x9f“\x96 Documentation\n\nPlease see here for full documentation on:\n\nGetting started (installation, setting up the environment, simple examples)\n\nHow-To examples (demos, integrations, helper functions)\n\nReference (full API docs)\n\nResources (high-level explanation of core concepts)\n\nð\x9f\x9a\x80 What can this help with?\n\nThere are six main areas that LangChain is designed to help with.\nThese are, in increasing order of complexity:\n\nð\x9f“\x83 LLMs and Prompts:\n\nThis includes prompt management, prompt optimization, a generic interface for all LLMs, and common utilities for working with LLMs.\n\nð\x9f”\x97 Chains:\n\nChains go beyond a single LLM call and involve sequences of calls (whether to an LLM or a different utility). LangChain provides a standard interface for chains, lots of integrations with other tools, and end-to-end chains for common applications.\n\nð\x9f“\x9a Data Augmented Generation:\n\nData Augmented Generation involves specific types of chains that first interact with an external data source to fetch data for use in the generation step. Examples include summarization of long pieces of text and question/answering over specific data sources.\n\nð\x9f¤\x96 Agents:\n\nAgents involve an LLM making decisions about which Actions to take, taking that Action, seeing an Observation, and repeating that until done. LangChain provides a standard interface for agents, a selection of agents to choose from, and examples of end-to-end agents.\n\nð\x9f§\xa0 Memory:\n\nMemory refers to persisting state between calls of a chain/agent. LangChain provides a standard interface for memory, a collection of memory implementations, and examples of chains/agents that use memory.\n\nð\x9f§\x90 Evaluation:\n\n[BETA] Generative models are notoriously hard to evaluate with traditional metrics. One new way of evaluating them is using language models themselves to do the evaluation. LangChain provides some prompts/chains for assisting in this.\n\nFor more information on these concepts, please see our full documentation.\n\nð\x9f’\x81 Contributing\n\nAs an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.\n\nFor detailed information on how to contribute, see here.", metadata={'source': '../../../../../README.md'})] Under the hood, Unstructured creates different "elements" for different chunks of text. By default we combine those together, but you can easily keep that separation by specifying mode="elements".

https://python.langchain.com/docs/modules/agents/concepts/

## Concepts The core idea of agents is to use a language model to choose a sequence of actions to take. In chains, a sequence of actions is hardcoded (in code). In agents, a language model is used as a reasoning engine to determine which actions to take and in which order. There are several key components here: ## Schema[​](#schema "Direct link to Schema") LangChain has several abstractions to make working with agents easy. ### AgentAction[​](#agentaction "Direct link to AgentAction") This is a dataclass that represents the action an agent should take. It has a `tool` property (which is the name of the tool that should be invoked) and a `tool_input` property (the input to that tool) ### AgentFinish[​](#agentfinish "Direct link to AgentFinish") This represents the final result from an agent, when it is ready to return to the user. It contains a `return_values` key-value mapping, which contains the final agent output. Usually, this contains an `output` key containing a string that is the agent's response. ### Intermediate Steps[​](#intermediate-steps "Direct link to Intermediate Steps") These represent previous agent actions and corresponding outputs from this CURRENT agent run. These are important to pass to future iteration so the agent knows what work it has already done. This is typed as a `List[Tuple[AgentAction, Any]]`. Note that observation is currently left as type `Any` to be maximally flexible. In practice, this is often a string. ## Agent[​](#agent "Direct link to Agent") This is the chain responsible for deciding what step to take next. This is usually powered by a language model, a prompt, and an output parser. Different agents have different prompting styles for reasoning, different ways of encoding inputs, and different ways of parsing the output. For a full list of built-in agents see [agent types](https://python.langchain.com/docs/modules/agents/agent_types/). You can also **easily build custom agents**, should you need further control. ### Agent Inputs[​](#agent-inputs "Direct link to Agent Inputs") The inputs to an agent are a key-value mapping. There is only one required key: `intermediate_steps`, which corresponds to `Intermediate Steps` as described above. Generally, the PromptTemplate takes care of transforming these pairs into a format that can best be passed into the LLM. ### Agent Outputs[​](#agent-outputs "Direct link to Agent Outputs") The output is the next action(s) to take or the final response to send to the user (`AgentAction`s or `AgentFinish`). Concretely, this can be typed as `Union[AgentAction, List[AgentAction], AgentFinish]`. The output parser is responsible for taking the raw LLM output and transforming it into one of these three types. ## AgentExecutor[​](#agentexecutor "Direct link to AgentExecutor") The agent executor is the runtime for an agent. This is what actually calls the agent, executes the actions it chooses, passes the action outputs back to the agent, and repeats. In pseudocode, this looks roughly like: ``` next_action = agent.get_action(...)while next_action != AgentFinish: observation = run(next_action) next_action = agent.get_action(..., next_action, observation)return next_action ``` While this may seem simple, there are several complexities this runtime handles for you, including: 1. Handling cases where the agent selects a non-existent tool 2. Handling cases where the tool errors 3. Handling cases where the agent produces output that cannot be parsed into a tool invocation 4. Logging and observability at all levels (agent decisions, tool calls) to stdout and/or to [LangSmith](https://python.langchain.com/docs/langsmith/). Tools are functions that an agent can invoke. The `Tool` abstraction consists of two components: 1. The input schema for the tool. This tells the LLM what parameters are needed to call the tool. Without this, it will not know what the correct inputs are. These parameters should be sensibly named and described. 2. The function to run. This is generally just a Python function that is invoked. ### Considerations[​](#considerations "Direct link to Considerations") There are two important design considerations around tools: 1. Giving the agent access to the right tools 2. Describing the tools in a way that is most helpful to the agent Without thinking through both, you won't be able to build a working agent. If you don't give the agent access to a correct set of tools, it will never be able to accomplish the objectives you give it. If you don't describe the tools well, the agent won't know how to use them properly. LangChain provides a wide set of built-in tools, but also makes it easy to define your own (including custom descriptions). For a full list of built-in tools, see the [tools integrations section](https://python.langchain.com/docs/integrations/tools/) For many common tasks, an agent will need a set of related tools. For this LangChain provides the concept of toolkits - groups of around 3-5 tools needed to accomplish specific objectives. For example, the GitHub toolkit has a tool for searching through GitHub issues, a tool for reading a file, a tool for commenting, etc. LangChain provides a wide set of toolkits to get started. For a full list of built-in toolkits, see the [toolkits integrations section](https://python.langchain.com/docs/integrations/toolkits/)

Concepts The core idea of agents is to use a language model to choose a sequence of actions to take. In chains, a sequence of actions is hardcoded (in code). In agents, a language model is used as a reasoning engine to determine which actions to take and in which order. There are several key components here: Schema​ LangChain has several abstractions to make working with agents easy. AgentAction​ This is a dataclass that represents the action an agent should take. It has a tool property (which is the name of the tool that should be invoked) and a tool_input property (the input to that tool) AgentFinish​ This represents the final result from an agent, when it is ready to return to the user. It contains a return_values key-value mapping, which contains the final agent output. Usually, this contains an output key containing a string that is the agent's response. Intermediate Steps​ These represent previous agent actions and corresponding outputs from this CURRENT agent run. These are important to pass to future iteration so the agent knows what work it has already done. This is typed as a List[Tuple[AgentAction, Any]]. Note that observation is currently left as type Any to be maximally flexible. In practice, this is often a string. Agent​ This is the chain responsible for deciding what step to take next. This is usually powered by a language model, a prompt, and an output parser. Different agents have different prompting styles for reasoning, different ways of encoding inputs, and different ways of parsing the output. For a full list of built-in agents see agent types. You can also easily build custom agents, should you need further control. Agent Inputs​ The inputs to an agent are a key-value mapping. There is only one required key: intermediate_steps, which corresponds to Intermediate Steps as described above. Generally, the PromptTemplate takes care of transforming these pairs into a format that can best be passed into the LLM. Agent Outputs​ The output is the next action(s) to take or the final response to send to the user (AgentActions or AgentFinish). Concretely, this can be typed as Union[AgentAction, List[AgentAction], AgentFinish]. The output parser is responsible for taking the raw LLM output and transforming it into one of these three types. AgentExecutor​ The agent executor is the runtime for an agent. This is what actually calls the agent, executes the actions it chooses, passes the action outputs back to the agent, and repeats. In pseudocode, this looks roughly like: next_action = agent.get_action(...) while next_action != AgentFinish: observation = run(next_action) next_action = agent.get_action(..., next_action, observation) return next_action While this may seem simple, there are several complexities this runtime handles for you, including: Handling cases where the agent selects a non-existent tool Handling cases where the tool errors Handling cases where the agent produces output that cannot be parsed into a tool invocation Logging and observability at all levels (agent decisions, tool calls) to stdout and/or to LangSmith. Tools are functions that an agent can invoke. The Tool abstraction consists of two components: The input schema for the tool. This tells the LLM what parameters are needed to call the tool. Without this, it will not know what the correct inputs are. These parameters should be sensibly named and described. The function to run. This is generally just a Python function that is invoked. Considerations​ There are two important design considerations around tools: Giving the agent access to the right tools Describing the tools in a way that is most helpful to the agent Without thinking through both, you won't be able to build a working agent. If you don't give the agent access to a correct set of tools, it will never be able to accomplish the objectives you give it. If you don't describe the tools well, the agent won't know how to use them properly. LangChain provides a wide set of built-in tools, but also makes it easy to define your own (including custom descriptions). For a full list of built-in tools, see the tools integrations section For many common tasks, an agent will need a set of related tools. For this LangChain provides the concept of toolkits - groups of around 3-5 tools needed to accomplish specific objectives. For example, the GitHub toolkit has a tool for searching through GitHub issues, a tool for reading a file, a tool for commenting, etc. LangChain provides a wide set of toolkits to get started. For a full list of built-in toolkits, see the toolkits integrations section

https://python.langchain.com/docs/modules/data_connection/document_loaders/file_directory/

## File Directory This covers how to load all documents in a directory. Under the hood, by default this uses the [UnstructuredLoader](https://python.langchain.com/docs/integrations/document_loaders/unstructured_file/). ``` from langchain_community.document_loaders import DirectoryLoader ``` We can use the `glob` parameter to control which files to load. Note that here it doesn't load the `.rst` file or the `.html` files. ``` loader = DirectoryLoader('../', glob="**/*.md") ``` ## Show a progress bar[​](#show-a-progress-bar "Direct link to Show a progress bar") By default a progress bar will not be shown. To show a progress bar, install the `tqdm` library (e.g. `pip install tqdm`), and set the `show_progress` parameter to `True`. ``` loader = DirectoryLoader('../', glob="**/*.md", show_progress=True)docs = loader.load() ``` ``` Requirement already satisfied: tqdm in /Users/jon/.pyenv/versions/3.9.16/envs/microbiome-app/lib/python3.9/site-packages (4.65.0) 0it [00:00, ?it/s] ``` ## Use multithreading[​](#use-multithreading "Direct link to Use multithreading") By default the loading happens in one thread. In order to utilize several threads set the `use_multithreading` flag to true. ``` loader = DirectoryLoader('../', glob="**/*.md", use_multithreading=True)docs = loader.load() ``` ## Change loader class[​](#change-loader-class "Direct link to Change loader class") By default this uses the `UnstructuredLoader` class. However, you can change up the type of loader pretty easily. ``` from langchain_community.document_loaders import TextLoader ``` ``` loader = DirectoryLoader('../', glob="**/*.md", loader_cls=TextLoader) ``` If you need to load Python source code files, use the `PythonLoader`. ``` from langchain_community.document_loaders import PythonLoader ``` ``` loader = DirectoryLoader('../../../../../', glob="**/*.py", loader_cls=PythonLoader) ``` ## Auto-detect file encodings with TextLoader[​](#auto-detect-file-encodings-with-textloader "Direct link to Auto-detect file encodings with TextLoader") In this example we will see some strategies that can be useful when loading a large list of arbitrary files from a directory using the `TextLoader` class. First to illustrate the problem, let's try to load multiple texts with arbitrary encodings. ``` path = '../../../../../tests/integration_tests/examples'loader = DirectoryLoader(path, glob="**/*.txt", loader_cls=TextLoader) ``` ### A. Default Behavior[​](#a-default-behavior "Direct link to A. Default Behavior") ``` <pre style="white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace"><span style="color: #800000; text-decoration-color: #800000">╭─────────────────────────────── </span><span style="color: #800000; text-decoration-color: #800000; font-weight: bold">Traceback </span><span style="color: #bf7f7f; text-decoration-color: #bf7f7f; font-weight: bold">(most recent call last)</span><span style="color: #800000; text-decoration-color: #800000"> ────────────────────────────────╮</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #bfbf7f; text-decoration-color: #bfbf7f">/data/source/langchain/langchain/document_loaders/</span><span style="color: #808000; text-decoration-color: #808000; font-weight: bold">text.py</span>:<span style="color: #0000ff; text-decoration-color: #0000ff">29</span> in <span style="color: #00ff00; text-decoration-color: #00ff00">load</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">26 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ </span>text = <span style="color: #808000; text-decoration-color: #808000">""</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">27 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">with</span> <span style="color: #00ffff; text-decoration-color: #00ffff">open</span>(<span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.file_path, encoding=<span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.encoding) <span style="color: #0000ff; text-decoration-color: #0000ff">as</span> f: <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">28 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">try</span>: <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">❱ </span>29 <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ </span>text = f.read() <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">30 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">except</span> <span style="color: #00ffff; text-decoration-color: #00ffff">UnicodeDecodeError</span> <span style="color: #0000ff; text-decoration-color: #0000ff">as</span> e: <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">31 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">if</span> <span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.autodetect_encoding: <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">32 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ </span>detected_encodings = <span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.detect_file_encodings() <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #bfbf7f; text-decoration-color: #bfbf7f">/home/spike/.pyenv/versions/3.9.11/lib/python3.9/</span><span style="color: #808000; text-decoration-color: #808000; font-weight: bold">codecs.py</span>:<span style="color: #0000ff; text-decoration-color: #0000ff">322</span> in <span style="color: #00ff00; text-decoration-color: #00ff00">decode</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f"> 319 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ </span><span style="color: #0000ff; text-decoration-color: #0000ff">def</span> <span style="color: #00ff00; text-decoration-color: #00ff00">decode</span>(<span style="color: #00ffff; text-decoration-color: #00ffff">self</span>, <span style="color: #00ffff; text-decoration-color: #00ffff">input</span>, final=<span style="color: #0000ff; text-decoration-color: #0000ff">False</span>): <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f"> 320 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f"># decode input (taking the buffer into account)</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f"> 321 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ </span>data = <span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.buffer + <span style="color: #00ffff; text-decoration-color: #00ffff">input</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">❱ </span> 322 <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ </span>(result, consumed) = <span style="color: #00ffff; text-decoration-color: #00ffff">self</span>._buffer_decode(data, <span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.errors, final) <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f"> 323 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f"># keep undecoded input until the next call</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f"> 324 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ </span><span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.buffer = data[consumed:] <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f"> 325 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">return</span> result <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">╰──────────────────────────────────────────────────────────────────────────────────────────────────╯</span><span style="color: #ff0000; text-decoration-color: #ff0000; font-weight: bold">UnicodeDecodeError: </span><span style="color: #008000; text-decoration-color: #008000">'utf-8'</span> codec can't decode byte <span style="color: #008080; text-decoration-color: #008080; font-weight: bold">0xca</span> in position <span style="color: #008080; text-decoration-color: #008080; font-weight: bold">0</span>: invalid continuation byte<span style="font-style: italic">The above exception was the direct cause of the following exception:</span><span style="color: #800000; text-decoration-color: #800000">╭─────────────────────────────── </span><span style="color: #800000; text-decoration-color: #800000; font-weight: bold">Traceback </span><span style="color: #bf7f7f; text-decoration-color: #bf7f7f; font-weight: bold">(most recent call last)</span><span style="color: #800000; text-decoration-color: #800000"> ────────────────────────────────╮</span><span style="color: #800000; text-decoration-color: #800000">│</span> in <span style="color: #00ff00; text-decoration-color: #00ff00">&lt;module&gt;</span>:<span style="color: #0000ff; text-decoration-color: #0000ff">1</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">❱ </span>1 loader.load() <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">2 </span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #bfbf7f; text-decoration-color: #bfbf7f">/data/source/langchain/langchain/document_loaders/</span><span style="color: #808000; text-decoration-color: #808000; font-weight: bold">directory.py</span>:<span style="color: #0000ff; text-decoration-color: #0000ff">84</span> in <span style="color: #00ff00; text-decoration-color: #00ff00">load</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">81 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">if</span> <span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.silent_errors: <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">82 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ │ </span>logger.warning(e) <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">83 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">else</span>: <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">❱ </span>84 <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">raise</span> e <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">85 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">finally</span>: <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">86 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">if</span> pbar: <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">87 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ │ </span>pbar.update(<span style="color: #0000ff; text-decoration-color: #0000ff">1</span>) <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #bfbf7f; text-decoration-color: #bfbf7f">/data/source/langchain/langchain/document_loaders/</span><span style="color: #808000; text-decoration-color: #808000; font-weight: bold">directory.py</span>:<span style="color: #0000ff; text-decoration-color: #0000ff">78</span> in <span style="color: #00ff00; text-decoration-color: #00ff00">load</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">75 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">if</span> i.is_file(): <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">76 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">if</span> _is_visible(i.relative_to(p)) <span style="color: #ff00ff; text-decoration-color: #ff00ff">or</span> <span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.load_hidden: <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">77 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">try</span>: <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">❱ </span>78 <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ </span>sub_docs = <span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.loader_cls(<span style="color: #00ffff; text-decoration-color: #00ffff">str</span>(i), **<span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.loader_kwargs).load() <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">79 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ </span>docs.extend(sub_docs) <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">80 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">except</span> <span style="color: #00ffff; text-decoration-color: #00ffff">Exception</span> <span style="color: #0000ff; text-decoration-color: #0000ff">as</span> e: <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">81 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">if</span> <span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.silent_errors: <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #bfbf7f; text-decoration-color: #bfbf7f">/data/source/langchain/langchain/document_loaders/</span><span style="color: #808000; text-decoration-color: #808000; font-weight: bold">text.py</span>:<span style="color: #0000ff; text-decoration-color: #0000ff">44</span> in <span style="color: #00ff00; text-decoration-color: #00ff00">load</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">41 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">except</span> <span style="color: #00ffff; text-decoration-color: #00ffff">UnicodeDecodeError</span>: <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">42 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">continue</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">43 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">else</span>: <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">❱ </span>44 <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">raise</span> <span style="color: #00ffff; text-decoration-color: #00ffff">RuntimeError</span>(<span style="color: #808000; text-decoration-color: #808000">f"Error loading {</span><span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.file_path<span style="color: #808000; text-decoration-color: #808000">}"</span>) <span style="color: #0000ff; text-decoration-color: #0000ff">from</span> <span style="color: #00ffff; text-decoration-color: #00ffff; text-decoration: underline">e</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">45 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">except</span> <span style="color: #00ffff; text-decoration-color: #00ffff">Exception</span> <span style="color: #0000ff; text-decoration-color: #0000ff">as</span> e: <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">46 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">raise</span> <span style="color: #00ffff; text-decoration-color: #00ffff">RuntimeError</span>(<span style="color: #808000; text-decoration-color: #808000">f"Error loading {</span><span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.file_path<span style="color: #808000; text-decoration-color: #808000">}"</span>) <span style="color: #0000ff; text-decoration-color: #0000ff">from</span> <span style="color: #00ffff; text-decoration-color: #00ffff; text-decoration: underline">e</span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">47 </span> <span style="color: #800000; text-decoration-color: #800000">│</span><span style="color: #800000; text-decoration-color: #800000">╰──────────────────────────────────────────────────────────────────────────────────────────────────╯</span><span style="color: #ff0000; text-decoration-color: #ff0000; font-weight: bold">RuntimeError: </span>Error loading ..<span style="color: #800080; text-decoration-color: #800080">/../../../../tests/integration_tests/examples/</span><span style="color: #ff00ff; text-decoration-color: #ff00ff">example-non-utf8.txt</span></pre> ``` The file `example-non-utf8.txt` uses a different encoding, so the `load()` function fails with a helpful message indicating which file failed decoding. With the default behavior of `TextLoader` any failure to load any of the documents will fail the whole loading process and no documents are loaded. ### B. Silent fail[​](#b-silent-fail "Direct link to B. Silent fail") We can pass the parameter `silent_errors` to the `DirectoryLoader` to skip the files which could not be loaded and continue the load process. ``` loader = DirectoryLoader(path, glob="**/*.txt", loader_cls=TextLoader, silent_errors=True)docs = loader.load() ``` ``` Error loading ../../../../../tests/integration_tests/examples/example-non-utf8.txt ``` ``` doc_sources = [doc.metadata['source'] for doc in docs]doc_sources ``` ``` ['../../../../../tests/integration_tests/examples/whatsapp_chat.txt', '../../../../../tests/integration_tests/examples/example-utf8.txt'] ``` ### C. Auto detect encodings[​](#c-auto-detect-encodings "Direct link to C. Auto detect encodings") We can also ask `TextLoader` to auto detect the file encoding before failing, by passing the `autodetect_encoding` to the loader class. ``` text_loader_kwargs={'autodetect_encoding': True}loader = DirectoryLoader(path, glob="**/*.txt", loader_cls=TextLoader, loader_kwargs=text_loader_kwargs)docs = loader.load() ``` ``` doc_sources = [doc.metadata['source'] for doc in docs]doc_sources ``` ``` ['../../../../../tests/integration_tests/examples/example-non-utf8.txt', '../../../../../tests/integration_tests/examples/whatsapp_chat.txt', '../../../../../tests/integration_tests/examples/example-utf8.txt'] ```

File Directory This covers how to load all documents in a directory. Under the hood, by default this uses the UnstructuredLoader. from langchain_community.document_loaders import DirectoryLoader We can use the glob parameter to control which files to load. Note that here it doesn't load the .rst file or the .html files. loader = DirectoryLoader('../', glob="**/*.md") Show a progress bar​ By default a progress bar will not be shown. To show a progress bar, install the tqdm library (e.g. pip install tqdm), and set the show_progress parameter to True. loader = DirectoryLoader('../', glob="**/*.md", show_progress=True) docs = loader.load() Requirement already satisfied: tqdm in /Users/jon/.pyenv/versions/3.9.16/envs/microbiome-app/lib/python3.9/site-packages (4.65.0) 0it [00:00, ?it/s] Use multithreading​ By default the loading happens in one thread. In order to utilize several threads set the use_multithreading flag to true. loader = DirectoryLoader('../', glob="**/*.md", use_multithreading=True) docs = loader.load() Change loader class​ By default this uses the UnstructuredLoader class. However, you can change up the type of loader pretty easily. from langchain_community.document_loaders import TextLoader loader = DirectoryLoader('../', glob="**/*.md", loader_cls=TextLoader) If you need to load Python source code files, use the PythonLoader. from langchain_community.document_loaders import PythonLoader loader = DirectoryLoader('../../../../../', glob="**/*.py", loader_cls=PythonLoader) Auto-detect file encodings with TextLoader​ In this example we will see some strategies that can be useful when loading a large list of arbitrary files from a directory using the TextLoader class. First to illustrate the problem, let's try to load multiple texts with arbitrary encodings. path = '../../../../../tests/integration_tests/examples' loader = DirectoryLoader(path, glob="**/*.txt", loader_cls=TextLoader) A. Default Behavior​ <pre style="white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace"><span style="color: #800000; text-decoration-color: #800000">╭─────────────────────────────── </span><span style="color: #800000; text-decoration-color: #800000; font-weight: bold">Traceback </span><span style="color: #bf7f7f; text-decoration-color: #bf7f7f; font-weight: bold">(most recent call last)</span><span style="color: #800000; text-decoration-color: #800000"> ────────────────────────────────╮</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #bfbf7f; text-decoration-color: #bfbf7f">/data/source/langchain/langchain/document_loaders/</span><span style="color: #808000; text-decoration-color: #808000; font-weight: bold">text.py</span>:<span style="color: #0000ff; text-decoration-color: #0000ff">29</span> in <span style="color: #00ff00; text-decoration-color: #00ff00">load</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">26 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ </span>text = <span style="color: #808000; text-decoration-color: #808000">""</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">27 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">with</span> <span style="color: #00ffff; text-decoration-color: #00ffff">open</span>(<span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.file_path, encoding=<span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.encoding) <span style="color: #0000ff; text-decoration-color: #0000ff">as</span> f: <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">28 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">try</span>: <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">❱ </span>29 <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ </span>text = f.read() <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">30 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">except</span> <span style="color: #00ffff; text-decoration-color: #00ffff">UnicodeDecodeError</span> <span style="color: #0000ff; text-decoration-color: #0000ff">as</span> e: <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">31 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">if</span> <span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.autodetect_encoding: <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">32 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ </span>detected_encodings = <span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.detect_file_encodings() <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #bfbf7f; text-decoration-color: #bfbf7f">/home/spike/.pyenv/versions/3.9.11/lib/python3.9/</span><span style="color: #808000; text-decoration-color: #808000; font-weight: bold">codecs.py</span>:<span style="color: #0000ff; text-decoration-color: #0000ff">322</span> in <span style="color: #00ff00; text-decoration-color: #00ff00">decode</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f"> 319 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ </span><span style="color: #0000ff; text-decoration-color: #0000ff">def</span> <span style="color: #00ff00; text-decoration-color: #00ff00">decode</span>(<span style="color: #00ffff; text-decoration-color: #00ffff">self</span>, <span style="color: #00ffff; text-decoration-color: #00ffff">input</span>, final=<span style="color: #0000ff; text-decoration-color: #0000ff">False</span>): <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f"> 320 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f"># decode input (taking the buffer into account)</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f"> 321 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ </span>data = <span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.buffer + <span style="color: #00ffff; text-decoration-color: #00ffff">input</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">❱ </span> 322 <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ </span>(result, consumed) = <span style="color: #00ffff; text-decoration-color: #00ffff">self</span>._buffer_decode(data, <span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.errors, final) <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f"> 323 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f"># keep undecoded input until the next call</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f"> 324 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ </span><span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.buffer = data[consumed:] <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f"> 325 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">return</span> result <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">╰──────────────────────────────────────────────────────────────────────────────────────────────────╯</span> <span style="color: #ff0000; text-decoration-color: #ff0000; font-weight: bold">UnicodeDecodeError: </span><span style="color: #008000; text-decoration-color: #008000">'utf-8'</span> codec can't decode byte <span style="color: #008080; text-decoration-color: #008080; font-weight: bold">0xca</span> in position <span style="color: #008080; text-decoration-color: #008080; font-weight: bold">0</span>: invalid continuation byte <span style="font-style: italic">The above exception was the direct cause of the following exception:</span> <span style="color: #800000; text-decoration-color: #800000">╭─────────────────────────────── </span><span style="color: #800000; text-decoration-color: #800000; font-weight: bold">Traceback </span><span style="color: #bf7f7f; text-decoration-color: #bf7f7f; font-weight: bold">(most recent call last)</span><span style="color: #800000; text-decoration-color: #800000"> ────────────────────────────────╮</span> <span style="color: #800000; text-decoration-color: #800000">│</span> in <span style="color: #00ff00; text-decoration-color: #00ff00">&lt;module&gt;</span>:<span style="color: #0000ff; text-decoration-color: #0000ff">1</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">❱ </span>1 loader.load() <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">2 </span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #bfbf7f; text-decoration-color: #bfbf7f">/data/source/langchain/langchain/document_loaders/</span><span style="color: #808000; text-decoration-color: #808000; font-weight: bold">directory.py</span>:<span style="color: #0000ff; text-decoration-color: #0000ff">84</span> in <span style="color: #00ff00; text-decoration-color: #00ff00">load</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">81 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">if</span> <span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.silent_errors: <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">82 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ │ </span>logger.warning(e) <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">83 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">else</span>: <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">❱ </span>84 <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">raise</span> e <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">85 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">finally</span>: <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">86 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">if</span> pbar: <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">87 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ │ </span>pbar.update(<span style="color: #0000ff; text-decoration-color: #0000ff">1</span>) <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #bfbf7f; text-decoration-color: #bfbf7f">/data/source/langchain/langchain/document_loaders/</span><span style="color: #808000; text-decoration-color: #808000; font-weight: bold">directory.py</span>:<span style="color: #0000ff; text-decoration-color: #0000ff">78</span> in <span style="color: #00ff00; text-decoration-color: #00ff00">load</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">75 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">if</span> i.is_file(): <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">76 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">if</span> _is_visible(i.relative_to(p)) <span style="color: #ff00ff; text-decoration-color: #ff00ff">or</span> <span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.load_hidden: <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">77 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">try</span>: <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">❱ </span>78 <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ </span>sub_docs = <span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.loader_cls(<span style="color: #00ffff; text-decoration-color: #00ffff">str</span>(i), **<span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.loader_kwargs).load() <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">79 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ </span>docs.extend(sub_docs) <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">80 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">except</span> <span style="color: #00ffff; text-decoration-color: #00ffff">Exception</span> <span style="color: #0000ff; text-decoration-color: #0000ff">as</span> e: <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">81 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">if</span> <span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.silent_errors: <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #bfbf7f; text-decoration-color: #bfbf7f">/data/source/langchain/langchain/document_loaders/</span><span style="color: #808000; text-decoration-color: #808000; font-weight: bold">text.py</span>:<span style="color: #0000ff; text-decoration-color: #0000ff">44</span> in <span style="color: #00ff00; text-decoration-color: #00ff00">load</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">41 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">except</span> <span style="color: #00ffff; text-decoration-color: #00ffff">UnicodeDecodeError</span>: <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">42 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">continue</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">43 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">else</span>: <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">❱ </span>44 <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">raise</span> <span style="color: #00ffff; text-decoration-color: #00ffff">RuntimeError</span>(<span style="color: #808000; text-decoration-color: #808000">f"Error loading {</span><span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.file_path<span style="color: #808000; text-decoration-color: #808000">}"</span>) <span style="color: #0000ff; text-decoration-color: #0000ff">from</span> <span style="color: #00ffff; text-decoration-color: #00ffff; text-decoration: underline">e</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">45 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">except</span> <span style="color: #00ffff; text-decoration-color: #00ffff">Exception</span> <span style="color: #0000ff; text-decoration-color: #0000ff">as</span> e: <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">46 </span><span style="color: #7f7f7f; text-decoration-color: #7f7f7f">│ │ │ │ </span><span style="color: #0000ff; text-decoration-color: #0000ff">raise</span> <span style="color: #00ffff; text-decoration-color: #00ffff">RuntimeError</span>(<span style="color: #808000; text-decoration-color: #808000">f"Error loading {</span><span style="color: #00ffff; text-decoration-color: #00ffff">self</span>.file_path<span style="color: #808000; text-decoration-color: #808000">}"</span>) <span style="color: #0000ff; text-decoration-color: #0000ff">from</span> <span style="color: #00ffff; text-decoration-color: #00ffff; text-decoration: underline">e</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #7f7f7f; text-decoration-color: #7f7f7f">47 </span> <span style="color: #800000; text-decoration-color: #800000">│</span> <span style="color: #800000; text-decoration-color: #800000">╰──────────────────────────────────────────────────────────────────────────────────────────────────╯</span> <span style="color: #ff0000; text-decoration-color: #ff0000; font-weight: bold">RuntimeError: </span>Error loading ..<span style="color: #800080; text-decoration-color: #800080">/../../../../tests/integration_tests/examples/</span><span style="color: #ff00ff; text-decoration-color: #ff00ff">example-non-utf8.txt</span> </pre> The file example-non-utf8.txt uses a different encoding, so the load() function fails with a helpful message indicating which file failed decoding. With the default behavior of TextLoader any failure to load any of the documents will fail the whole loading process and no documents are loaded. B. Silent fail​ We can pass the parameter silent_errors to the DirectoryLoader to skip the files which could not be loaded and continue the load process. loader = DirectoryLoader(path, glob="**/*.txt", loader_cls=TextLoader, silent_errors=True) docs = loader.load() Error loading ../../../../../tests/integration_tests/examples/example-non-utf8.txt doc_sources = [doc.metadata['source'] for doc in docs] doc_sources ['../../../../../tests/integration_tests/examples/whatsapp_chat.txt', '../../../../../tests/integration_tests/examples/example-utf8.txt'] C. Auto detect encodings​ We can also ask TextLoader to auto detect the file encoding before failing, by passing the autodetect_encoding to the loader class. text_loader_kwargs={'autodetect_encoding': True} loader = DirectoryLoader(path, glob="**/*.txt", loader_cls=TextLoader, loader_kwargs=text_loader_kwargs) docs = loader.load() doc_sources = [doc.metadata['source'] for doc in docs] doc_sources ['../../../../../tests/integration_tests/examples/example-non-utf8.txt', '../../../../../tests/integration_tests/examples/whatsapp_chat.txt', '../../../../../tests/integration_tests/examples/example-utf8.txt']

https://python.langchain.com/docs/modules/data_connection/document_loaders/office_file/

## Microsoft Office > [The Microsoft Office](https://www.office.com/) suite of productivity software includes Microsoft Word, Microsoft Excel, Microsoft PowerPoint, Microsoft Outlook, and Microsoft OneNote. It is available for Microsoft Windows and macOS operating systems. It is also available on Android and iOS. This covers how to load commonly used file formats including `DOCX`, `XLSX` and `PPTX` documents into a document format that we can use downstream. ## Loading DOCX, XLSX, PPTX with AzureAIDocumentIntelligenceLoader[​](#loading-docx-xlsx-pptx-with-azureaidocumentintelligenceloader "Direct link to Loading DOCX, XLSX, PPTX with AzureAIDocumentIntelligenceLoader") [Azure AI Document Intelligence](https://aka.ms/doc-intelligence) (formerly known as `Azure Form Recognizer`) is machine-learning based service that extracts texts (including handwriting), tables, document structures (e.g., titles, section headings, etc.) and key-value-pairs from digital or scanned PDFs, images, Office and HTML files. Document Intelligence supports `PDF`, `JPEG/JPG`, `PNG`, `BMP`, `TIFF`, `HEIF`, `DOCX`, `XLSX`, `PPTX` and `HTML`. This [current implementation](https://aka.ms/di-langchain) of a loader using `Document Intelligence` can incorporate content page-wise and turn it into LangChain documents. The default output format is markdown, which can be easily chained with `MarkdownHeaderTextSplitter` for semantic document chunking. You can also use `mode="single"` or `mode="page"` to return pure texts in a single page or document split by page. ### Prerequisite[​](#prerequisite "Direct link to Prerequisite") An Azure AI Document Intelligence resource in one of the 3 preview regions: **East US**, **West US2**, **West Europe** - follow [this document](https://learn.microsoft.com/azure/ai-services/document-intelligence/create-document-intelligence-resource?view=doc-intel-4.0.0) to create one if you don't have. You will be passing `<endpoint>` and `<key>` as parameters to the loader. ``` %pip install --upgrade --quiet langchain langchain-community azure-ai-documentintelligencefrom langchain_community.document_loaders import AzureAIDocumentIntelligenceLoaderfile_path = "<filepath>"endpoint = "<endpoint>"key = "<key>"loader = AzureAIDocumentIntelligenceLoader( api_endpoint=endpoint, api_key=key, file_path=file_path, api_model="prebuilt-layout")documents = loader.load() ```

Microsoft Office The Microsoft Office suite of productivity software includes Microsoft Word, Microsoft Excel, Microsoft PowerPoint, Microsoft Outlook, and Microsoft OneNote. It is available for Microsoft Windows and macOS operating systems. It is also available on Android and iOS. This covers how to load commonly used file formats including DOCX, XLSX and PPTX documents into a document format that we can use downstream. Loading DOCX, XLSX, PPTX with AzureAIDocumentIntelligenceLoader​ Azure AI Document Intelligence (formerly known as Azure Form Recognizer) is machine-learning based service that extracts texts (including handwriting), tables, document structures (e.g., titles, section headings, etc.) and key-value-pairs from digital or scanned PDFs, images, Office and HTML files. Document Intelligence supports PDF, JPEG/JPG, PNG, BMP, TIFF, HEIF, DOCX, XLSX, PPTX and HTML. This current implementation of a loader using Document Intelligence can incorporate content page-wise and turn it into LangChain documents. The default output format is markdown, which can be easily chained with MarkdownHeaderTextSplitter for semantic document chunking. You can also use mode="single" or mode="page" to return pure texts in a single page or document split by page. Prerequisite​ An Azure AI Document Intelligence resource in one of the 3 preview regions: East US, West US2, West Europe - follow this document to create one if you don't have. You will be passing <endpoint> and <key> as parameters to the loader. %pip install --upgrade --quiet langchain langchain-community azure-ai-documentintelligence from langchain_community.document_loaders import AzureAIDocumentIntelligenceLoader file_path = "<filepath>" endpoint = "<endpoint>" key = "<key>" loader = AzureAIDocumentIntelligenceLoader( api_endpoint=endpoint, api_key=key, file_path=file_path, api_model="prebuilt-layout" ) documents = loader.load()

https://python.langchain.com/docs/modules/agents/how_to/agent_iter/

It can be useful to run the agent as an iterator, to add human-in-the-loop checks as needed. To demonstrate the `AgentExecutorIterator` functionality, we will set up a problem where an Agent must: In this simple problem we can demonstrate adding some logic to verify intermediate steps by checking whether their outputs are prime. ``` from langchain.agents import AgentType, initialize_agentfrom langchain.chains import LLMMathChainfrom langchain_core.pydantic_v1 import BaseModel, Fieldfrom langchain_core.tools import Toolfrom langchain_openai import ChatOpenAI ``` ``` # need to use GPT-4 here as GPT-3.5 does not understand, however hard you insist, that# it should use the calculator to perform the final calculationllm = ChatOpenAI(temperature=0, model="gpt-4")llm_math_chain = LLMMathChain.from_llm(llm=llm, verbose=True) ``` ``` primes = {998: 7901, 999: 7907, 1000: 7919}class CalculatorInput(BaseModel): question: str = Field()class PrimeInput(BaseModel): n: int = Field()def is_prime(n: int) -> bool: if n <= 1 or (n % 2 == 0 and n > 2): return False for i in range(3, int(n**0.5) + 1, 2): if n % i == 0: return False return Truedef get_prime(n: int, primes: dict = primes) -> str: return str(primes.get(int(n)))async def aget_prime(n: int, primes: dict = primes) -> str: return str(primes.get(int(n)))tools = [ Tool( name="GetPrime", func=get_prime, description="A tool that returns the `n`th prime number", args_schema=PrimeInput, coroutine=aget_prime, ), Tool.from_function( func=llm_math_chain.run, name="Calculator", description="Useful for when you need to compute mathematical expressions", args_schema=CalculatorInput, coroutine=llm_math_chain.arun, ),] ``` Construct the agent. We will use OpenAI Functions agent here. ``` from langchain import hub# Get the prompt to use - you can modify this!# You can see the full prompt used at: https://smith.langchain.com/hub/hwchase17/openai-functions-agentprompt = hub.pull("hwchase17/openai-functions-agent") ``` ``` from langchain.agents import create_openai_functions_agentagent = create_openai_functions_agent(llm, tools, prompt) ``` ``` from langchain.agents import AgentExecutoragent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) ``` ``` question = "What is the product of the 998th, 999th and 1000th prime numbers?"for step in agent_executor.iter({"input": question}): if output := step.get("intermediate_step"): action, value = output[0] if action.tool == "GetPrime": print(f"Checking whether {value} is prime...") assert is_prime(int(value)) # Ask user if they want to continue _continue = input("Should the agent continue (Y/n)?:\n") or "Y" if _continue.lower() != "y": break ``` ``` > Entering new AgentExecutor chain...Invoking: `GetPrime` with `{'n': 998}`7901Checking whether 7901 is prime...Should the agent continue (Y/n)?:yInvoking: `GetPrime` with `{'n': 999}`7907Checking whether 7907 is prime...Should the agent continue (Y/n)?:yInvoking: `GetPrime` with `{'n': 1000}`7919Checking whether 7919 is prime...Should the agent continue (Y/n)?:yInvoking: `Calculator` with `{'question': '7901 * 7907 * 7919'}`> Entering new LLMMathChain chain...7901 * 7907 * 7919```text7901 * 7907 * 7919```...numexpr.evaluate("7901 * 7907 * 7919")...Answer: 494725326233> Finished chain.Answer: 494725326233Should the agent continue (Y/n)?:yThe product of the 998th, 999th and 1000th prime numbers is 494,725,326,233.> Finished chain. ```

It can be useful to run the agent as an iterator, to add human-in-the-loop checks as needed. To demonstrate the AgentExecutorIterator functionality, we will set up a problem where an Agent must: In this simple problem we can demonstrate adding some logic to verify intermediate steps by checking whether their outputs are prime. from langchain.agents import AgentType, initialize_agent from langchain.chains import LLMMathChain from langchain_core.pydantic_v1 import BaseModel, Field from langchain_core.tools import Tool from langchain_openai import ChatOpenAI # need to use GPT-4 here as GPT-3.5 does not understand, however hard you insist, that # it should use the calculator to perform the final calculation llm = ChatOpenAI(temperature=0, model="gpt-4") llm_math_chain = LLMMathChain.from_llm(llm=llm, verbose=True) primes = {998: 7901, 999: 7907, 1000: 7919} class CalculatorInput(BaseModel): question: str = Field() class PrimeInput(BaseModel): n: int = Field() def is_prime(n: int) -> bool: if n <= 1 or (n % 2 == 0 and n > 2): return False for i in range(3, int(n**0.5) + 1, 2): if n % i == 0: return False return True def get_prime(n: int, primes: dict = primes) -> str: return str(primes.get(int(n))) async def aget_prime(n: int, primes: dict = primes) -> str: return str(primes.get(int(n))) tools = [ Tool( name="GetPrime", func=get_prime, description="A tool that returns the `n`th prime number", args_schema=PrimeInput, coroutine=aget_prime, ), Tool.from_function( func=llm_math_chain.run, name="Calculator", description="Useful for when you need to compute mathematical expressions", args_schema=CalculatorInput, coroutine=llm_math_chain.arun, ), ] Construct the agent. We will use OpenAI Functions agent here. from langchain import hub # Get the prompt to use - you can modify this! # You can see the full prompt used at: https://smith.langchain.com/hub/hwchase17/openai-functions-agent prompt = hub.pull("hwchase17/openai-functions-agent") from langchain.agents import create_openai_functions_agent agent = create_openai_functions_agent(llm, tools, prompt) from langchain.agents import AgentExecutor agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) question = "What is the product of the 998th, 999th and 1000th prime numbers?" for step in agent_executor.iter({"input": question}): if output := step.get("intermediate_step"): action, value = output[0] if action.tool == "GetPrime": print(f"Checking whether {value} is prime...") assert is_prime(int(value)) # Ask user if they want to continue _continue = input("Should the agent continue (Y/n)?:\n") or "Y" if _continue.lower() != "y": break > Entering new AgentExecutor chain... Invoking: `GetPrime` with `{'n': 998}` 7901Checking whether 7901 is prime... Should the agent continue (Y/n)?: y Invoking: `GetPrime` with `{'n': 999}` 7907Checking whether 7907 is prime... Should the agent continue (Y/n)?: y Invoking: `GetPrime` with `{'n': 1000}` 7919Checking whether 7919 is prime... Should the agent continue (Y/n)?: y Invoking: `Calculator` with `{'question': '7901 * 7907 * 7919'}` > Entering new LLMMathChain chain... 7901 * 7907 * 7919```text 7901 * 7907 * 7919 ``` ...numexpr.evaluate("7901 * 7907 * 7919")... Answer: 494725326233 > Finished chain. Answer: 494725326233Should the agent continue (Y/n)?: y The product of the 998th, 999th and 1000th prime numbers is 494,725,326,233. > Finished chain.

https://python.langchain.com/docs/modules/data_connection/document_loaders/pdf/

[Portable Document Format (PDF)](https://en.wikipedia.org/wiki/PDF), standardized as ISO 32000, is a file format developed by Adobe in 1992 to present documents, including text formatting and images, in a manner independent of application software, hardware, and operating systems. This covers how to load `PDF` documents into the Document format that we use downstream. Load PDF using `pypdf` into array of documents, where each document contains the page content and metadata with `page` number. An advantage of this approach is that documents can be retrieved with page numbers. We want to use `OpenAIEmbeddings` so we have to get the OpenAI API Key. Under the hood, Unstructured creates different "elements" for different chunks of text. By default we combine those together, but you can easily keep that separation by specifying `mode="elements"`. ``` Document(page_content='LayoutParser: A Unified Toolkit for Deep\nLearning Based Document Image Analysis\nZejiang Shen1 (�), Ruochen Zhang2, Melissa Dell3, Benjamin Charles Germain\nLee4, Jacob Carlson3, and Weining Li5\n1 Allen Institute for AI\nshannons@allenai.org\n2 Brown University\nruochen zhang@brown.edu\n3 Harvard University\n{melissadell,jacob carlson}@fas.harvard.edu\n4 University of Washington\nbcgl@cs.washington.edu\n5 University of Waterloo\nw422li@uwaterloo.ca\nAbstract. Recent advances in document image analysis (DIA) have been\nprimarily driven by the application of neural networks. Ideally, research\noutcomes could be easily deployed in production and extended for further\ninvestigation. However, various factors like loosely organized codebases\nand sophisticated model configurations complicate the easy reuse of im-\nportant innovations by a wide audience. Though there have been on-going\nefforts to improve reusability and simplify deep learning (DL) model\ndevelopment in disciplines like natural language processing and computer\nvision, none of them are optimized for challenges in the domain of DIA.\nThis represents a major gap in the existing toolkit, as DIA is central to\nacademic research across a wide range of disciplines in the social sciences\nand humanities. This paper introduces LayoutParser, an open-source\nlibrary for streamlining the usage of DL in DIA research and applica-\ntions. The core LayoutParser library comes with a set of simple and\nintuitive interfaces for applying and customizing DL models for layout de-\ntection, character recognition, and many other document processing tasks.\nTo promote extensibility, LayoutParser also incorporates a community\nplatform for sharing both pre-trained models and full document digiti-\nzation pipelines. We demonstrate that LayoutParser is helpful for both\nlightweight and large-scale digitization pipelines in real-word use cases.\nThe library is publicly available at https://layout-parser.github.io.\nKeywords: Document Image Analysis · Deep Learning · Layout Analysis\n· Character Recognition · Open Source library · Toolkit.\n1\nIntroduction\nDeep Learning(DL)-based approaches are the state-of-the-art for a wide range of\ndocument image analysis (DIA) tasks including document image classification [11,\narXiv:2103.15348v2 [cs.CV] 21 Jun 2021\n', lookup_str='', metadata={'file_path': 'example_data/layout-parser-paper.pdf', 'page_number': 1, 'total_pages': 16, 'format': 'PDF 1.5', 'title': '', 'author': '', 'subject': '', 'keywords': '', 'creator': 'LaTeX with hyperref', 'producer': 'pdfTeX-1.40.21', 'creationDate': 'D:20210622012710Z', 'modDate': 'D:20210622012710Z', 'trapped': '', 'encryption': None}, lookup_index=0) ``` Note: all other PDF loaders can also be used to fetch remote PDFs, but `OnlinePDFLoader` is a legacy function, and works specifically with `UnstructuredPDFLoader`. ``` [Document(page_content='A WEAK ( k, k ) -LEFSCHETZ THEOREM FOR PROJECTIVE TORIC ORBIFOLDS\n\nWilliam D. Montoya\n\nInstituto de Matem´atica, Estat´ıstica e Computa¸c˜ao Cient´ıfica,\n\nIn [3] we proved that, under suitable conditions, on a very general codimension s quasi- smooth intersection subvariety X in a projective toric orbifold P d Σ with d + s = 2 ( k + 1 ) the Hodge conjecture holds, that is, every ( p, p ) -cohomology class, under the Poincar´e duality is a rational linear combination of fundamental classes of algebraic subvarieties of X . The proof of the above-mentioned result relies, for p ≠ d + 1 − s , on a Lefschetz\n\nKeywords: (1,1)- Lefschetz theorem, Hodge conjecture, toric varieties, complete intersection Email: wmontoya@ime.unicamp.br\n\ntheorem ([7]) and the Hard Lefschetz theorem for projective orbifolds ([11]). When p = d + 1 − s the proof relies on the Cayley trick, a trick which associates to X a quasi-smooth hypersurface Y in a projective vector bundle, and the Cayley Proposition (4.3) which gives an isomorphism of some primitive cohomologies (4.2) of X and Y . The Cayley trick, following the philosophy of Mavlyutov in [7], reduces results known for quasi-smooth hypersurfaces to quasi-smooth intersection subvarieties. The idea in this paper goes the other way around, we translate some results for quasi-smooth intersection subvarieties to\n\nAcknowledgement. I thank Prof. Ugo Bruzzo and Tiago Fonseca for useful discus- sions. I also acknowledge support from FAPESP postdoctoral grant No. 2019/23499-7.\n\nLet M be a free abelian group of rank d , let N = Hom ( M, Z ) , and N R = N ⊗ Z R .\n\nif there exist k linearly independent primitive elements e\n\n, . . . , e k ∈ N such that σ = { µ\n\ne\n\n+ ⋯ + µ k e k } . • The generators e i are integral if for every i and any nonnegative rational number µ the product µe i is in N only if µ is an integer. • Given two rational simplicial cones σ , σ ′ one says that σ ′ is a face of σ ( σ ′ < σ ) if the set of integral generators of σ ′ is a subset of the set of integral generators of σ . • A finite set Σ = { σ\n\n, . . . , σ t } of rational simplicial cones is called a rational simplicial complete d -dimensional fan if:\n\nall faces of cones in Σ are in Σ ;\n\nif σ, σ ′ ∈ Σ then σ ∩ σ ′ < σ and σ ∩ σ ′ < σ ′ ;\n\nN R = σ\n\n∪ ⋅ ⋅ ⋅ ∪ σ t .\n\nA rational simplicial complete d -dimensional fan Σ defines a d -dimensional toric variety P d Σ having only orbifold singularities which we assume to be projective. Moreover, T ∶ = N ⊗ Z C ∗ ≃ ( C ∗ ) d is the torus action on P d Σ . We denote by Σ ( i ) the i -dimensional cones\n\nFor a cone σ ∈ Σ, ˆ σ is the set of 1-dimensional cone in Σ that are not contained in σ\n\nand x ˆ σ ∶ = ∏ ρ ∈ ˆ σ x ρ is the associated monomial in S .\n\nDefinition 2.2. The irrelevant ideal of P d Σ is the monomial ideal B Σ ∶ =< x ˆ σ ∣ σ ∈ Σ > and the zero locus Z ( Σ ) ∶ = V ( B Σ ) in the affine space A d ∶ = Spec ( S ) is the irrelevant locus.\n\nProposition 2.3 (Theorem 5.1.11 [5]) . The toric variety P d Σ is a categorical quotient A d ∖ Z ( Σ ) by the group Hom ( Cl ( Σ ) , C ∗ ) and the group action is induced by the Cl ( Σ ) - grading of S .\n\nNow we give a brief introduction to complex orbifolds and we mention the needed theorems for the next section. Namely: de Rham theorem and Dolbeault theorem for complex orbifolds.\n\nDefinition 2.4. A complex orbifold of complex dimension d is a singular complex space whose singularities are locally isomorphic to quotient singularities C d / G , for finite sub- groups G ⊂ Gl ( d, C ) .\n\nDefinition 2.5. A differential form on a complex orbifold Z is defined locally at z ∈ Z as a G -invariant differential form on C d where G ⊂ Gl ( d, C ) and Z is locally isomorphic to d\n\nRoughly speaking the local geometry of orbifolds reduces to local G -invariant geometry.\n\nWe have a complex of differential forms ( A ● ( Z ) , d ) and a double complex ( A ● , ● ( Z ) , ∂, ¯ ∂ ) of bigraded differential forms which define the de Rham and the Dolbeault cohomology groups (for a fixed p ∈ N ) respectively:\n\n(1,1)-Lefschetz theorem for projective toric orbifolds\n\nDefinition 3.1. A subvariety X ⊂ P d Σ is quasi-smooth if V ( I X ) ⊂ A #Σ ( 1 ) is smooth outside\n\nExample 3.2 . Quasi-smooth hypersurfaces or more generally quasi-smooth intersection sub-\n\nExample 3.2 . Quasi-smooth hypersurfaces or more generally quasi-smooth intersection sub- varieties are quasi-smooth subvarieties (see [2] or [7] for more details).\n\nRemark 3.3 . Quasi-smooth subvarieties are suborbifolds of P d Σ in the sense of Satake in [8]. Intuitively speaking they are subvarieties whose only singularities come from the ambient\n\nProof. From the exponential short exact sequence\n\nwe have a long exact sequence in cohomology\n\nH 1 (O ∗ X ) → H 2 ( X, Z ) → H 2 (O X ) ≃ H 0 , 2 ( X )\n\nwhere the last isomorphisms is due to Steenbrink in [9]. Now, it is enough to prove the commutativity of the next diagram\n\nwhere the last isomorphisms is due to Steenbrink in [9]. Now,\n\nH 2 ( X, Z ) / / H 2 ( X, O X ) ≃ Dolbeault H 2 ( X, C ) deRham ≃ H 2 dR ( X, C ) / / H 0 , 2 ¯ ∂ ( X )\n\nof the proof follows as the ( 1 , 1 ) -Lefschetz theorem in [6].\n\nRemark 3.5 . For k = 1 and P d Σ as the projective space, we recover the classical ( 1 , 1 ) - Lefschetz theorem.\n\nBy the Hard Lefschetz Theorem for projective orbifolds (see [11] for details) we\n\nBy the Hard Lefschetz Theorem for projective orbifolds (see [11] for details) we get an isomorphism of cohomologies :\n\ngiven by the Lefschetz morphism and since it is a morphism of Hodge structures, we have:\n\nH 1 , 1 ( X, Q ) ≃ H dim X − 1 , dim X − 1 ( X, Q )\n\nCorollary 3.6. If the dimension of X is 1 , 2 or 3 . The Hodge conjecture holds on X\n\nProof. If the dim C X = 1 the result is clear by the Hard Lefschetz theorem for projective orbifolds. The dimension 2 and 3 cases are covered by Theorem 3.5 and the Hard Lefschetz.\n\nCayley trick and Cayley proposition\n\nThe Cayley trick is a way to associate to a quasi-smooth intersection subvariety a quasi- smooth hypersurface. Let L 1 , . . . , L s be line bundles on P d Σ and let π ∶ P ( E ) → P d Σ be the projective space bundle associated to the vector bundle E = L 1 ⊕ ⋯ ⊕ L s . It is known that P ( E ) is a ( d + s − 1 ) -dimensional simplicial toric variety whose fan depends on the degrees of the line bundles and the fan Σ. Furthermore, if the Cox ring, without considering the grading, of P d Σ is C [ x 1 , . . . , x m ] then the Cox ring of P ( E ) is\n\nMoreover for X a quasi-smooth intersection subvariety cut off by f 1 , . . . , f s with deg ( f i ) = [ L i ] we relate the hypersurface Y cut off by F = y 1 f 1 + ⋅ ⋅ ⋅ + y s f s which turns out to be quasi-smooth. For more details see Section 2 in [7].\n\nWe will denote P ( E ) as P d + s − 1 Σ ,X to keep track of its relation with X and P d Σ .\n\nThe following is a key remark.\n\nRemark 4.1 . There is a morphism ι ∶ X → Y ⊂ P d + s − 1 Σ ,X . Moreover every point z ∶ = ( x, y ) ∈ Y with y ≠ 0 has a preimage. Hence for any subvariety W = V ( I W ) ⊂ X ⊂ P d Σ there exists W ′ ⊂ Y ⊂ P d + s − 1 Σ ,X such that π ( W ′ ) = W , i.e., W ′ = { z = ( x, y ) ∣ x ∈ W } .\n\nFor X ⊂ P d Σ a quasi-smooth intersection variety the morphism in cohomology induced by the inclusion i ∗ ∶ H d − s ( P d Σ , C ) → H d − s ( X, C ) is injective by Proposition 1.4 in [7].\n\nDefinition 4.2. The primitive cohomology of H d − s prim ( X ) is the quotient H d − s ( X, C )/ i ∗ ( H d − s ( P d Σ , C )) and H d − s prim ( X, Q ) with rational coefficients.\n\nH d − s ( P d Σ , C ) and H d − s ( X, C ) have pure Hodge structures, and the morphism i ∗ is com- patible with them, so that H d − s prim ( X ) gets a pure Hodge structure.\n\nThe next Proposition is the Cayley proposition.\n\nProposition 4.3. [Proposition 2.3 in [3] ] Let X = X 1 ∩⋅ ⋅ ⋅∩ X s be a quasi-smooth intersec- tion subvariety in P d Σ cut off by homogeneous polynomials f 1 . . . f s . Then for p ≠ d + s − 1 2 , d + s − 3 2\n\nRemark 4.5 . The above isomorphisms are also true with rational coefficients since H ● ( X, C ) = H ● ( X, Q ) ⊗ Q C . See the beginning of Section 7.1 in [10] for more details.\n\nTheorem 5.1. Let Y = { F = y 1 f 1 + ⋯ + y k f k = 0 } ⊂ P 2 k + 1 Σ ,X be the quasi-smooth hypersurface associated to the quasi-smooth intersection surface X = X f 1 ∩ ⋅ ⋅ ⋅ ∩ X f k ⊂ P k + 2 Σ . Then on Y the Hodge conjecture holds.\n\nthe Hodge conjecture holds.\n\nProof. If H k,k prim ( X, Q ) = 0 we are done. So let us assume H k,k prim ( X, Q ) ≠ 0. By the Cayley proposition H k,k prim ( Y, Q ) ≃ H 1 , 1 prim ( X, Q ) and by the ( 1 , 1 ) -Lefschetz theorem for projective\n\ntoric orbifolds there is a non-zero algebraic basis λ C 1 , . . . , λ C n with rational coefficients of H 1 , 1 prim ( X, Q ) , that is, there are n ∶ = h 1 , 1 prim ( X, Q ) algebraic curves C 1 , . . . , C n in X such that under the Poincar´e duality the class in homology [ C i ] goes to λ C i , [ C i ] ↦ λ C i . Recall that the Cox ring of P k + 2 is contained in the Cox ring of P 2 k + 1 Σ ,X without considering the grading. Considering the grading we have that if α ∈ Cl ( P k + 2 Σ ) then ( α, 0 ) ∈ Cl ( P 2 k + 1 Σ ,X ) . So the polynomials defining C i ⊂ P k + 2 Σ can be interpreted in P 2 k + 1 X, Σ but with different degree. Moreover, by Remark 4.1 each C i is contained in Y = { F = y 1 f 1 + ⋯ + y k f k = 0 } and\n\nfurthermore it has codimension k .\n\nClaim: { C i } ni = 1 is a basis of prim ( ) . It is enough to prove that λ C i is different from zero in H k,k prim ( Y, Q ) or equivalently that the cohomology classes { λ C i } ni = 1 do not come from the ambient space. By contradiction, let us assume that there exists a j and C ⊂ P 2 k + 1 Σ ,X such that λ C ∈ H k,k ( P 2 k + 1 Σ ,X , Q ) with i ∗ ( λ C ) = λ C j or in terms of homology there exists a ( k + 2 ) -dimensional algebraic subvariety V ⊂ P 2 k + 1 Σ ,X such that V ∩ Y = C j so they are equal as a homology class of P 2 k + 1 Σ ,X ,i.e., [ V ∩ Y ] = [ C j ] . It is easy to check that π ( V ) ∩ X = C j as a subvariety of P k + 2 Σ where π ∶ ( x, y ) ↦ x . Hence [ π ( V ) ∩ X ] = [ C j ] which is equivalent to say that λ C j comes from P k + 2 Σ which contradicts the choice of [ C j ] .\n\nRemark 5.2 . Into the proof of the previous theorem, the key fact was that on X the Hodge conjecture holds and we translate it to Y by contradiction. So, using an analogous argument we have:\n\nargument we have:\n\nProposition 5.3. Let Y = { F = y 1 f s +⋯+ y s f s = 0 } ⊂ P 2 k + 1 Σ ,X be the quasi-smooth hypersurface associated to a quasi-smooth intersection subvariety X = X f 1 ∩ ⋅ ⋅ ⋅ ∩ X f s ⊂ P d Σ such that d + s = 2 ( k + 1 ) . If the Hodge conjecture holds on X then it holds as well on Y .\n\nCorollary 5.4. If the dimension of Y is 2 s − 1 , 2 s or 2 s + 1 then the Hodge conjecture holds on Y .\n\nProof. By Proposition 5.3 and Corollary 3.6.\n\n[\n\n] Angella, D. Cohomologies of certain orbifolds. Journal of Geometry and Physics\n\n(\n\n),\n\n–\n\n[\n\n] Batyrev, V. V., and Cox, D. A. On the Hodge structure of projective hypersur- faces in toric varieties. Duke Mathematical Journal\n\n,\n\n(Aug\n\n). [\n\n] Bruzzo, U., and Montoya, W. On the Hodge conjecture for quasi-smooth in- tersections in toric varieties. S˜ao Paulo J. Math. Sci. Special Section: Geometry in Algebra and Algebra in Geometry (\n\n). [\n\n] Caramello Jr, F. C. Introduction to orbifolds. a\n\niv:\n\nv\n\n(\n\n). [\n\n] Cox, D., Little, J., and Schenck, H. Toric varieties, vol.\n\nAmerican Math- ematical Soc.,\n\n[\n\n] Griffiths, P., and Harris, J. Principles of Algebraic Geometry. John Wiley & Sons, Ltd,\n\n[\n\n] Mavlyutov, A. R. Cohomology of complete intersections in toric varieties. Pub- lished in Pacific J. of Math.\n\nNo.\n\n(\n\n),\n\n–\n\n[\n\n] Satake, I. On a Generalization of the Notion of Manifold. Proceedings of the National Academy of Sciences of the United States of America\n\n,\n\n(\n\n),\n\n–\n\n[\n\n] Steenbrink, J. H. M. Intersection form for quasi-homogeneous singularities. Com- positio Mathematica\n\n,\n\n(\n\n),\n\n–\n\n[\n\n] Voisin, C. Hodge Theory and Complex Algebraic Geometry I, vol.\n\nof Cambridge Studies in Advanced Mathematics . Cambridge University Press,\n\n[\n\n] Wang, Z. Z., and Zaffran, D. A remark on the Hard Lefschetz theorem for K¨ahler orbifolds. Proceedings of the American Mathematical Society\n\n,\n\n(Aug\n\n).\n\n[2] Batyrev, V. V., and Cox, D. A. On the Hodge structure of projective hypersur- faces in toric varieties. Duke Mathematical Journal 75, 2 (Aug 1994).\n\n[\n\n] Bruzzo, U., and Montoya, W. On the Hodge conjecture for quasi-smooth in- tersections in toric varieties. S˜ao Paulo J. Math. Sci. Special Section: Geometry in Algebra and Algebra in Geometry (\n\n).\n\n[3] Bruzzo, U., and Montoya, W. On the Hodge conjecture for quasi-smooth in- tersections in toric varieties. S˜ao Paulo J. Math. Sci. Special Section: Geometry in Algebra and Algebra in Geometry (2021).\n\nA. R. Cohomology of complete intersections in toric varieties. Pub-', lookup_str='', metadata={'source': '/var/folders/ph/hhm7_zyx4l13k3v8z02dwp1w0000gn/T/tmpgq0ckaja/online_file.pdf'}, lookup_index=0)] ``` This can be helpful for chunking texts semantically into sections as the output html content can be parsed via `BeautifulSoup` to get more structured and rich information about font size, page numbers, PDF headers/footers, etc. ``` from langchain_community.docstore.document import Documentcur_idx = -1semantic_snippets = []# Assumption: headings have higher font size than their respective contentfor s in snippets: # if current snippet's font size > previous section's heading => it is a new heading if not semantic_snippets or s[1] > semantic_snippets[cur_idx].metadata['heading_font']: metadata={'heading':s[0], 'content_font': 0, 'heading_font': s[1]} metadata.update(data.metadata) semantic_snippets.append(Document(page_content='',metadata=metadata)) cur_idx += 1 continue # if current snippet's font size <= previous section's content => content belongs to the same section (one can also create # a tree like structure for sub sections if needed but that may require some more thinking and may be data specific) if not semantic_snippets[cur_idx].metadata['content_font'] or s[1] <= semantic_snippets[cur_idx].metadata['content_font']: semantic_snippets[cur_idx].page_content += s[0] semantic_snippets[cur_idx].metadata['content_font'] = max(s[1], semantic_snippets[cur_idx].metadata['content_font']) continue # if current snippet's font size > previous section's content but less than previous section's heading than also make a new # section (e.g. title of a PDF will have the highest font size but we don't want it to subsume all sections) metadata={'heading':s[0], 'content_font': 0, 'heading_font': s[1]} metadata.update(data.metadata) semantic_snippets.append(Document(page_content='',metadata=metadata)) cur_idx += 1 ``` ``` Document(page_content='Recently, various DL models and datasets have been developed for layout analysis\ntasks. The dhSegment [22] utilizes fully convolutional networks [20] for segmen-\ntation tasks on historical documents. Object detection-based methods like Faster\nR-CNN [28] and Mask R-CNN [12] are used for identifying document elements [38]\nand detecting tables [30, 26]. Most recently, Graph Neural Networks [29] have also\nbeen used in table detection [27]. However, these models are usually implemented\nindividually and there is no unified framework to load and use such models.\nThere has been a surge of interest in creating open-source tools for document\nimage processing: a search of document image analysis in Github leads to 5M\nrelevant code pieces 6; yet most of them rely on traditional rule-based methods\nor provide limited functionalities. The closest prior research to our work is the\nOCR-D project7, which also tries to build a complete toolkit for DIA. However,\nsimilar to the platform developed by Neudecker et al. [21], it is designed for\nanalyzing historical documents, and provides no supports for recent DL models.\nThe DocumentLayoutAnalysis project8 focuses on processing born-digital PDF\ndocuments via analyzing the stored PDF data. Repositories like DeepLayout9\nand Detectron2-PubLayNet10 are individual deep learning models trained on\nlayout analysis datasets without support for the full DIA pipeline. The Document\nAnalysis and Exploitation (DAE) platform [15] and the DeepDIVA project [2]\naim to improve the reproducibility of DIA methods (or DL models), yet they\nare not actively maintained. OCR engines like Tesseract [14], easyOCR11 and\npaddleOCR12 usually do not come with comprehensive functionalities for other\nDIA tasks like layout analysis.\nRecent years have also seen numerous efforts to create libraries for promoting\nreproducibility and reusability in the field of DL. Libraries like Dectectron2 [35],\n6 The number shown is obtained by specifying the search type as ‘code’.\n7 https://ocr-d.de/en/about\n8 https://github.com/BobLd/DocumentLayoutAnalysis\n9 https://github.com/leonlulu/DeepLayout\n10 https://github.com/hpanwar08/detectron2\n11 https://github.com/JaidedAI/EasyOCR\n12 https://github.com/PaddlePaddle/PaddleOCR\n4\nZ. Shen et al.\nFig. 1: The overall architecture of LayoutParser. For an input document image,\nthe core LayoutParser library provides a set of off-the-shelf tools for layout\ndetection, OCR, visualization, and storage, backed by a carefully designed layout\ndata structure. LayoutParser also supports high level customization via efficient\nlayout annotation and model training functions. These improve model accuracy\non the target samples. The community platform enables the easy sharing of DIA\nmodels and whole digitization pipelines to promote reusability and reproducibility.\nA collection of detailed documentation, tutorials and exemplar projects make\nLayoutParser easy to learn and use.\nAllenNLP [8] and transformers [34] have provided the community with complete\nDL-based support for developing and deploying models for general computer\nvision and natural language processing problems. LayoutParser, on the other\nhand, specializes specifically in DIA tasks. LayoutParser is also equipped with a\ncommunity platform inspired by established model hubs such as Torch Hub [23]\nand TensorFlow Hub [1]. It enables the sharing of pretrained models as well as\nfull document processing pipelines that are unique to DIA tasks.\nThere have been a variety of document data collections to facilitate the\ndevelopment of DL models. Some examples include PRImA [3](magazine layouts),\nPubLayNet [38](academic paper layouts), Table Bank [18](tables in academic\npapers), Newspaper Navigator Dataset [16, 17](newspaper figure layouts) and\nHJDataset [31](historical Japanese document layouts). A spectrum of models\ntrained on these datasets are currently available in the LayoutParser model zoo\nto support different use cases.\n', metadata={'heading': '2 Related Work\n', 'content_font': 9, 'heading_font': 11, 'source': 'example_data/layout-parser-paper.pdf'}) ``` This is the fastest of the PDF parsing options, and contains detailed metadata about the PDF and its pages, as well as returns one document per page. ``` Document(page_content='LayoutParser: A Unified Toolkit for Deep\nLearning Based Document Image Analysis\nZejiang Shen1 (�), Ruochen Zhang2, Melissa Dell3, Benjamin Charles Germain\nLee4, Jacob Carlson3, and Weining Li5\n1 Allen Institute for AI\nshannons@allenai.org\n2 Brown University\nruochen zhang@brown.edu\n3 Harvard University\n{melissadell,jacob carlson}@fas.harvard.edu\n4 University of Washington\nbcgl@cs.washington.edu\n5 University of Waterloo\nw422li@uwaterloo.ca\nAbstract. Recent advances in document image analysis (DIA) have been\nprimarily driven by the application of neural networks. Ideally, research\noutcomes could be easily deployed in production and extended for further\ninvestigation. However, various factors like loosely organized codebases\nand sophisticated model configurations complicate the easy reuse of im-\nportant innovations by a wide audience. Though there have been on-going\nefforts to improve reusability and simplify deep learning (DL) model\ndevelopment in disciplines like natural language processing and computer\nvision, none of them are optimized for challenges in the domain of DIA.\nThis represents a major gap in the existing toolkit, as DIA is central to\nacademic research across a wide range of disciplines in the social sciences\nand humanities. This paper introduces LayoutParser, an open-source\nlibrary for streamlining the usage of DL in DIA research and applica-\ntions. The core LayoutParser library comes with a set of simple and\nintuitive interfaces for applying and customizing DL models for layout de-\ntection, character recognition, and many other document processing tasks.\nTo promote extensibility, LayoutParser also incorporates a community\nplatform for sharing both pre-trained models and full document digiti-\nzation pipelines. We demonstrate that LayoutParser is helpful for both\nlightweight and large-scale digitization pipelines in real-word use cases.\nThe library is publicly available at https://layout-parser.github.io.\nKeywords: Document Image Analysis · Deep Learning · Layout Analysis\n· Character Recognition · Open Source library · Toolkit.\n1\nIntroduction\nDeep Learning(DL)-based approaches are the state-of-the-art for a wide range of\ndocument image analysis (DIA) tasks including document image classification [11,\narXiv:2103.15348v2 [cs.CV] 21 Jun 2021\n', lookup_str='', metadata={'file_path': 'example_data/layout-parser-paper.pdf', 'page_number': 1, 'total_pages': 16, 'format': 'PDF 1.5', 'title': '', 'author': '', 'subject': '', 'keywords': '', 'creator': 'LaTeX with hyperref', 'producer': 'pdfTeX-1.40.21', 'creationDate': 'D:20210622012710Z', 'modDate': 'D:20210622012710Z', 'trapped': '', 'encryption': None}, lookup_index=0) ``` Additionally, you can pass along any of the options from the [PyMuPDF documentation](https://pymupdf.readthedocs.io/en/latest/app1.html#plain-text/) as keyword arguments in the `load` call, and it will be pass along to the `get_text()` call. Like PyMuPDF, the output Documents contain detailed metadata about the PDF and its pages, and returns one document per page. ``` Document(page_content='LayoutParser: A Unified Toolkit for Deep\nLearning Based Document Image Analysis\nZejiang Shen1 ((cid:0)), Ruochen Zhang2, Melissa Dell3, Benjamin Charles Germain\nLee4, Jacob Carlson3, and Weining Li5\n1 Allen Institute for AI\n1202 shannons@allenai.org\n2 Brown University\nruochen zhang@brown.edu\n3 Harvard University\nnuJ {melissadell,jacob carlson}@fas.harvard.edu\n4 University of Washington\nbcgl@cs.washington.edu\n12 5 University of Waterloo\nw422li@uwaterloo.ca\n]VC.sc[\nAbstract. Recentadvancesindocumentimageanalysis(DIA)havebeen\nprimarily driven by the application of neural networks. Ideally, research\noutcomescouldbeeasilydeployedinproductionandextendedforfurther\ninvestigation. However, various factors like loosely organized codebases\nand sophisticated model configurations complicate the easy reuse of im-\n2v84351.3012:viXra portantinnovationsbyawideaudience.Thoughtherehavebeenon-going\nefforts to improve reusability and simplify deep learning (DL) model\ndevelopmentindisciplineslikenaturallanguageprocessingandcomputer\nvision, none of them are optimized for challenges in the domain of DIA.\nThis represents a major gap in the existing toolkit, as DIA is central to\nacademicresearchacross awiderangeof disciplinesinthesocialsciences\nand humanities. This paper introduces LayoutParser, an open-source\nlibrary for streamlining the usage of DL in DIA research and applica-\ntions. The core LayoutParser library comes with a set of simple and\nintuitiveinterfacesforapplyingandcustomizingDLmodelsforlayoutde-\ntection,characterrecognition,andmanyotherdocumentprocessingtasks.\nTo promote extensibility, LayoutParser also incorporates a community\nplatform for sharing both pre-trained models and full document digiti-\nzation pipelines. We demonstrate that LayoutParser is helpful for both\nlightweight and large-scale digitization pipelines in real-word use cases.\nThe library is publicly available at https://layout-parser.github.io.\nKeywords: DocumentImageAnalysis·DeepLearning·LayoutAnalysis\n· Character Recognition · Open Source library · Toolkit.\n1 Introduction\nDeep Learning(DL)-based approaches are the state-of-the-art for a wide range of\ndocumentimageanalysis(DIA)tasksincludingdocumentimageclassification[11,', metadata={'source': 'example_data/layout-parser-paper.pdf', 'file_path': 'example_data/layout-parser-paper.pdf', 'page': 1, 'total_pages': 16, 'Author': '', 'CreationDate': 'D:20210622012710Z', 'Creator': 'LaTeX with hyperref', 'Keywords': '', 'ModDate': 'D:20210622012710Z', 'PTEX.Fullbanner': 'This is pdfTeX, Version 3.14159265-2.6-1.40.21 (TeX Live 2020) kpathsea version 6.3.2', 'Producer': 'pdfTeX-1.40.21', 'Subject': '', 'Title': '', 'Trapped': 'False'}) ``` The AmazonTextractPDFLoader calls the [Amazon Textract Service](https://aws.amazon.com/textract/) to convert PDFs into a Document structure. The loader does pure OCR at the moment, with more features like layout support planned, depending on demand. Single and multi-page documents are supported with up to 3000 pages and 512 MB of size. For the call to be successful an AWS account is required, similar to the [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) requirements. Besides the AWS configuration, it is very similar to the other PDF loaders, while also supporting JPEG, PNG and TIFF and non-native PDF formats. [Azure AI Document Intelligence](https://aka.ms/doc-intelligence) (formerly known as `Azure Form Recognizer`) is machine-learning based service that extracts texts (including handwriting), tables, document structures (e.g., titles, section headings, etc.) and key-value-pairs from digital or scanned PDFs, images, Office and HTML files. Document Intelligence supports `PDF`, `JPEG/JPG`, `PNG`, `BMP`, `TIFF`, `HEIF`, `DOCX`, `XLSX`, `PPTX` and `HTML`. This [current implementation](https://aka.ms/di-langchain) of a loader using `Document Intelligence` can incorporate content page-wise and turn it into LangChain documents. The default output format is markdown, which can be easily chained with `MarkdownHeaderTextSplitter` for semantic document chunking. You can also use `mode="single"` or `mode="page"` to return pure texts in a single page or document split by page. An Azure AI Document Intelligence resource in one of the 3 preview regions: **East US**, **West US2**, **West Europe** - follow [this document](https://learn.microsoft.com/azure/ai-services/document-intelligence/create-document-intelligence-resource?view=doc-intel-4.0.0) to create one if you don't have. You will be passing `<endpoint>` and `<key>` as parameters to the loader.

Portable Document Format (PDF), standardized as ISO 32000, is a file format developed by Adobe in 1992 to present documents, including text formatting and images, in a manner independent of application software, hardware, and operating systems. This covers how to load PDF documents into the Document format that we use downstream. Load PDF using pypdf into array of documents, where each document contains the page content and metadata with page number. An advantage of this approach is that documents can be retrieved with page numbers. We want to use OpenAIEmbeddings so we have to get the OpenAI API Key. Under the hood, Unstructured creates different "elements" for different chunks of text. By default we combine those together, but you can easily keep that separation by specifying mode="elements". Document(page_content='LayoutParser: A Unified Toolkit for Deep\nLearning Based Document Image Analysis\nZejiang Shen1 (�), Ruochen Zhang2, Melissa Dell3, Benjamin Charles Germain\nLee4, Jacob Carlson3, and Weining Li5\n1 Allen Institute for AI\nshannons@allenai.org\n2 Brown University\nruochen zhang@brown.edu\n3 Harvard University\n{melissadell,jacob carlson}@fas.harvard.edu\n4 University of Washington\nbcgl@cs.washington.edu\n5 University of Waterloo\nw422li@uwaterloo.ca\nAbstract. Recent advances in document image analysis (DIA) have been\nprimarily driven by the application of neural networks. Ideally, research\noutcomes could be easily deployed in production and extended for further\ninvestigation. However, various factors like loosely organized codebases\nand sophisticated model configurations complicate the easy reuse of im-\nportant innovations by a wide audience. Though there have been on-going\nefforts to improve reusability and simplify deep learning (DL) model\ndevelopment in disciplines like natural language processing and computer\nvision, none of them are optimized for challenges in the domain of DIA.\nThis represents a major gap in the existing toolkit, as DIA is central to\nacademic research across a wide range of disciplines in the social sciences\nand humanities. This paper introduces LayoutParser, an open-source\nlibrary for streamlining the usage of DL in DIA research and applica-\ntions. The core LayoutParser library comes with a set of simple and\nintuitive interfaces for applying and customizing DL models for layout de-\ntection, character recognition, and many other document processing tasks.\nTo promote extensibility, LayoutParser also incorporates a community\nplatform for sharing both pre-trained models and full document digiti-\nzation pipelines. We demonstrate that LayoutParser is helpful for both\nlightweight and large-scale digitization pipelines in real-word use cases.\nThe library is publicly available at https://layout-parser.github.io.\nKeywords: Document Image Analysis · Deep Learning · Layout Analysis\n· Character Recognition · Open Source library · Toolkit.\n1\nIntroduction\nDeep Learning(DL)-based approaches are the state-of-the-art for a wide range of\ndocument image analysis (DIA) tasks including document image classification [11,\narXiv:2103.15348v2 [cs.CV] 21 Jun 2021\n', lookup_str='', metadata={'file_path': 'example_data/layout-parser-paper.pdf', 'page_number': 1, 'total_pages': 16, 'format': 'PDF 1.5', 'title': '', 'author': '', 'subject': '', 'keywords': '', 'creator': 'LaTeX with hyperref', 'producer': 'pdfTeX-1.40.21', 'creationDate': 'D:20210622012710Z', 'modDate': 'D:20210622012710Z', 'trapped': '', 'encryption': None}, lookup_index=0) Note: all other PDF loaders can also be used to fetch remote PDFs, but OnlinePDFLoader is a legacy function, and works specifically with UnstructuredPDFLoader. [Document(page_content='A WEAK ( k, k ) -LEFSCHETZ THEOREM FOR PROJECTIVE TORIC ORBIFOLDS\n\nWilliam D. Montoya\n\nInstituto de Matem´atica, Estat´ıstica e Computa¸c˜ao Cient´ıfica,\n\nIn [3] we proved that, under suitable conditions, on a very general codimension s quasi- smooth intersection subvariety X in a projective toric orbifold P d Σ with d + s = 2 ( k + 1 ) the Hodge conjecture holds, that is, every ( p, p ) -cohomology class, under the Poincar´e duality is a rational linear combination of fundamental classes of algebraic subvarieties of X . The proof of the above-mentioned result relies, for p ≠ d + 1 − s , on a Lefschetz\n\nKeywords: (1,1)- Lefschetz theorem, Hodge conjecture, toric varieties, complete intersection Email: wmontoya@ime.unicamp.br\n\ntheorem ([7]) and the Hard Lefschetz theorem for projective orbifolds ([11]). When p = d + 1 − s the proof relies on the Cayley trick, a trick which associates to X a quasi-smooth hypersurface Y in a projective vector bundle, and the Cayley Proposition (4.3) which gives an isomorphism of some primitive cohomologies (4.2) of X and Y . The Cayley trick, following the philosophy of Mavlyutov in [7], reduces results known for quasi-smooth hypersurfaces to quasi-smooth intersection subvarieties. The idea in this paper goes the other way around, we translate some results for quasi-smooth intersection subvarieties to\n\nAcknowledgement. I thank Prof. Ugo Bruzzo and Tiago Fonseca for useful discus- sions. I also acknowledge support from FAPESP postdoctoral grant No. 2019/23499-7.\n\nLet M be a free abelian group of rank d , let N = Hom ( M, Z ) , and N R = N ⊗ Z R .\n\nif there exist k linearly independent primitive elements e\n\n, . . . , e k ∈ N such that σ = { µ\n\ne\n\n+ ⋯ + µ k e k } . • The generators e i are integral if for every i and any nonnegative rational number µ the product µe i is in N only if µ is an integer. • Given two rational simplicial cones σ , σ ′ one says that σ ′ is a face of σ ( σ ′ < σ ) if the set of integral generators of σ ′ is a subset of the set of integral generators of σ . • A finite set Σ = { σ\n\n, . . . , σ t } of rational simplicial cones is called a rational simplicial complete d -dimensional fan if:\n\nall faces of cones in Σ are in Σ ;\n\nif σ, σ ′ ∈ Σ then σ ∩ σ ′ < σ and σ ∩ σ ′ < σ ′ ;\n\nN R = σ\n\n∪ ⋅ ⋅ ⋅ ∪ σ t .\n\nA rational simplicial complete d -dimensional fan Σ defines a d -dimensional toric variety P d Σ having only orbifold singularities which we assume to be projective. Moreover, T ∶ = N ⊗ Z C ∗ ≃ ( C ∗ ) d is the torus action on P d Σ . We denote by Σ ( i ) the i -dimensional cones\n\nFor a cone σ ∈ Σ, ˆ σ is the set of 1-dimensional cone in Σ that are not contained in σ\n\nand x ˆ σ ∶ = ∏ ρ ∈ ˆ σ x ρ is the associated monomial in S .\n\nDefinition 2.2. The irrelevant ideal of P d Σ is the monomial ideal B Σ ∶ =< x ˆ σ ∣ σ ∈ Σ > and the zero locus Z ( Σ ) ∶ = V ( B Σ ) in the affine space A d ∶ = Spec ( S ) is the irrelevant locus.\n\nProposition 2.3 (Theorem 5.1.11 [5]) . The toric variety P d Σ is a categorical quotient A d ∖ Z ( Σ ) by the group Hom ( Cl ( Σ ) , C ∗ ) and the group action is induced by the Cl ( Σ ) - grading of S .\n\nNow we give a brief introduction to complex orbifolds and we mention the needed theorems for the next section. Namely: de Rham theorem and Dolbeault theorem for complex orbifolds.\n\nDefinition 2.4. A complex orbifold of complex dimension d is a singular complex space whose singularities are locally isomorphic to quotient singularities C d / G , for finite sub- groups G ⊂ Gl ( d, C ) .\n\nDefinition 2.5. A differential form on a complex orbifold Z is defined locally at z ∈ Z as a G -invariant differential form on C d where G ⊂ Gl ( d, C ) and Z is locally isomorphic to d\n\nRoughly speaking the local geometry of orbifolds reduces to local G -invariant geometry.\n\nWe have a complex of differential forms ( A ● ( Z ) , d ) and a double complex ( A ● , ● ( Z ) , ∂, ¯ ∂ ) of bigraded differential forms which define the de Rham and the Dolbeault cohomology groups (for a fixed p ∈ N ) respectively:\n\n(1,1)-Lefschetz theorem for projective toric orbifolds\n\nDefinition 3.1. A subvariety X ⊂ P d Σ is quasi-smooth if V ( I X ) ⊂ A #Σ ( 1 ) is smooth outside\n\nExample 3.2 . Quasi-smooth hypersurfaces or more generally quasi-smooth intersection sub-\n\nExample 3.2 . Quasi-smooth hypersurfaces or more generally quasi-smooth intersection sub- varieties are quasi-smooth subvarieties (see [2] or [7] for more details).\n\nRemark 3.3 . Quasi-smooth subvarieties are suborbifolds of P d Σ in the sense of Satake in [8]. Intuitively speaking they are subvarieties whose only singularities come from the ambient\n\nProof. From the exponential short exact sequence\n\nwe have a long exact sequence in cohomology\n\nH 1 (O ∗ X ) → H 2 ( X, Z ) → H 2 (O X ) ≃ H 0 , 2 ( X )\n\nwhere the last isomorphisms is due to Steenbrink in [9]. Now, it is enough to prove the commutativity of the next diagram\n\nwhere the last isomorphisms is due to Steenbrink in [9]. Now,\n\nH 2 ( X, Z ) / / H 2 ( X, O X ) ≃ Dolbeault H 2 ( X, C ) deRham ≃ H 2 dR ( X, C ) / / H 0 , 2 ¯ ∂ ( X )\n\nof the proof follows as the ( 1 , 1 ) -Lefschetz theorem in [6].\n\nRemark 3.5 . For k = 1 and P d Σ as the projective space, we recover the classical ( 1 , 1 ) - Lefschetz theorem.\n\nBy the Hard Lefschetz Theorem for projective orbifolds (see [11] for details) we\n\nBy the Hard Lefschetz Theorem for projective orbifolds (see [11] for details) we get an isomorphism of cohomologies :\n\ngiven by the Lefschetz morphism and since it is a morphism of Hodge structures, we have:\n\nH 1 , 1 ( X, Q ) ≃ H dim X − 1 , dim X − 1 ( X, Q )\n\nCorollary 3.6. If the dimension of X is 1 , 2 or 3 . The Hodge conjecture holds on X\n\nProof. If the dim C X = 1 the result is clear by the Hard Lefschetz theorem for projective orbifolds. The dimension 2 and 3 cases are covered by Theorem 3.5 and the Hard Lefschetz.\n\nCayley trick and Cayley proposition\n\nThe Cayley trick is a way to associate to a quasi-smooth intersection subvariety a quasi- smooth hypersurface. Let L 1 , . . . , L s be line bundles on P d Σ and let π ∶ P ( E ) → P d Σ be the projective space bundle associated to the vector bundle E = L 1 ⊕ ⋯ ⊕ L s . It is known that P ( E ) is a ( d + s − 1 ) -dimensional simplicial toric variety whose fan depends on the degrees of the line bundles and the fan Σ. Furthermore, if the Cox ring, without considering the grading, of P d Σ is C [ x 1 , . . . , x m ] then the Cox ring of P ( E ) is\n\nMoreover for X a quasi-smooth intersection subvariety cut off by f 1 , . . . , f s with deg ( f i ) = [ L i ] we relate the hypersurface Y cut off by F = y 1 f 1 + ⋅ ⋅ ⋅ + y s f s which turns out to be quasi-smooth. For more details see Section 2 in [7].\n\nWe will denote P ( E ) as P d + s − 1 Σ ,X to keep track of its relation with X and P d Σ .\n\nThe following is a key remark.\n\nRemark 4.1 . There is a morphism ι ∶ X → Y ⊂ P d + s − 1 Σ ,X . Moreover every point z ∶ = ( x, y ) ∈ Y with y ≠ 0 has a preimage. Hence for any subvariety W = V ( I W ) ⊂ X ⊂ P d Σ there exists W ′ ⊂ Y ⊂ P d + s − 1 Σ ,X such that π ( W ′ ) = W , i.e., W ′ = { z = ( x, y ) ∣ x ∈ W } .\n\nFor X ⊂ P d Σ a quasi-smooth intersection variety the morphism in cohomology induced by the inclusion i ∗ ∶ H d − s ( P d Σ , C ) → H d − s ( X, C ) is injective by Proposition 1.4 in [7].\n\nDefinition 4.2. The primitive cohomology of H d − s prim ( X ) is the quotient H d − s ( X, C )/ i ∗ ( H d − s ( P d Σ , C )) and H d − s prim ( X, Q ) with rational coefficients.\n\nH d − s ( P d Σ , C ) and H d − s ( X, C ) have pure Hodge structures, and the morphism i ∗ is com- patible with them, so that H d − s prim ( X ) gets a pure Hodge structure.\n\nThe next Proposition is the Cayley proposition.\n\nProposition 4.3. [Proposition 2.3 in [3] ] Let X = X 1 ∩⋅ ⋅ ⋅∩ X s be a quasi-smooth intersec- tion subvariety in P d Σ cut off by homogeneous polynomials f 1 . . . f s . Then for p ≠ d + s − 1 2 , d + s − 3 2\n\nRemark 4.5 . The above isomorphisms are also true with rational coefficients since H ● ( X, C ) = H ● ( X, Q ) ⊗ Q C . See the beginning of Section 7.1 in [10] for more details.\n\nTheorem 5.1. Let Y = { F = y 1 f 1 + ⋯ + y k f k = 0 } ⊂ P 2 k + 1 Σ ,X be the quasi-smooth hypersurface associated to the quasi-smooth intersection surface X = X f 1 ∩ ⋅ ⋅ ⋅ ∩ X f k ⊂ P k + 2 Σ . Then on Y the Hodge conjecture holds.\n\nthe Hodge conjecture holds.\n\nProof. If H k,k prim ( X, Q ) = 0 we are done. So let us assume H k,k prim ( X, Q ) ≠ 0. By the Cayley proposition H k,k prim ( Y, Q ) ≃ H 1 , 1 prim ( X, Q ) and by the ( 1 , 1 ) -Lefschetz theorem for projective\n\ntoric orbifolds there is a non-zero algebraic basis λ C 1 , . . . , λ C n with rational coefficients of H 1 , 1 prim ( X, Q ) , that is, there are n ∶ = h 1 , 1 prim ( X, Q ) algebraic curves C 1 , . . . , C n in X such that under the Poincar´e duality the class in homology [ C i ] goes to λ C i , [ C i ] ↦ λ C i . Recall that the Cox ring of P k + 2 is contained in the Cox ring of P 2 k + 1 Σ ,X without considering the grading. Considering the grading we have that if α ∈ Cl ( P k + 2 Σ ) then ( α, 0 ) ∈ Cl ( P 2 k + 1 Σ ,X ) . So the polynomials defining C i ⊂ P k + 2 Σ can be interpreted in P 2 k + 1 X, Σ but with different degree. Moreover, by Remark 4.1 each C i is contained in Y = { F = y 1 f 1 + ⋯ + y k f k = 0 } and\n\nfurthermore it has codimension k .\n\nClaim: { C i } ni = 1 is a basis of prim ( ) . It is enough to prove that λ C i is different from zero in H k,k prim ( Y, Q ) or equivalently that the cohomology classes { λ C i } ni = 1 do not come from the ambient space. By contradiction, let us assume that there exists a j and C ⊂ P 2 k + 1 Σ ,X such that λ C ∈ H k,k ( P 2 k + 1 Σ ,X , Q ) with i ∗ ( λ C ) = λ C j or in terms of homology there exists a ( k + 2 ) -dimensional algebraic subvariety V ⊂ P 2 k + 1 Σ ,X such that V ∩ Y = C j so they are equal as a homology class of P 2 k + 1 Σ ,X ,i.e., [ V ∩ Y ] = [ C j ] . It is easy to check that π ( V ) ∩ X = C j as a subvariety of P k + 2 Σ where π ∶ ( x, y ) ↦ x . Hence [ π ( V ) ∩ X ] = [ C j ] which is equivalent to say that λ C j comes from P k + 2 Σ which contradicts the choice of [ C j ] .\n\nRemark 5.2 . Into the proof of the previous theorem, the key fact was that on X the Hodge conjecture holds and we translate it to Y by contradiction. So, using an analogous argument we have:\n\nargument we have:\n\nProposition 5.3. Let Y = { F = y 1 f s +⋯+ y s f s = 0 } ⊂ P 2 k + 1 Σ ,X be the quasi-smooth hypersurface associated to a quasi-smooth intersection subvariety X = X f 1 ∩ ⋅ ⋅ ⋅ ∩ X f s ⊂ P d Σ such that d + s = 2 ( k + 1 ) . If the Hodge conjecture holds on X then it holds as well on Y .\n\nCorollary 5.4. If the dimension of Y is 2 s − 1 , 2 s or 2 s + 1 then the Hodge conjecture holds on Y .\n\nProof. By Proposition 5.3 and Corollary 3.6.\n\n[\n\n] Angella, D. Cohomologies of certain orbifolds. Journal of Geometry and Physics\n\n(\n\n),\n\n–\n\n[\n\n] Batyrev, V. V., and Cox, D. A. On the Hodge structure of projective hypersur- faces in toric varieties. Duke Mathematical Journal\n\n,\n\n(Aug\n\n). [\n\n] Bruzzo, U., and Montoya, W. On the Hodge conjecture for quasi-smooth in- tersections in toric varieties. S˜ao Paulo J. Math. Sci. Special Section: Geometry in Algebra and Algebra in Geometry (\n\n). [\n\n] Caramello Jr, F. C. Introduction to orbifolds. a\n\niv:\n\nv\n\n(\n\n). [\n\n] Cox, D., Little, J., and Schenck, H. Toric varieties, vol.\n\nAmerican Math- ematical Soc.,\n\n[\n\n] Griffiths, P., and Harris, J. Principles of Algebraic Geometry. John Wiley & Sons, Ltd,\n\n[\n\n] Mavlyutov, A. R. Cohomology of complete intersections in toric varieties. Pub- lished in Pacific J. of Math.\n\nNo.\n\n(\n\n),\n\n–\n\n[\n\n] Satake, I. On a Generalization of the Notion of Manifold. Proceedings of the National Academy of Sciences of the United States of America\n\n,\n\n(\n\n),\n\n–\n\n[\n\n] Steenbrink, J. H. M. Intersection form for quasi-homogeneous singularities. Com- positio Mathematica\n\n,\n\n(\n\n),\n\n–\n\n[\n\n] Voisin, C. Hodge Theory and Complex Algebraic Geometry I, vol.\n\nof Cambridge Studies in Advanced Mathematics . Cambridge University Press,\n\n[\n\n] Wang, Z. Z., and Zaffran, D. A remark on the Hard Lefschetz theorem for K¨ahler orbifolds. Proceedings of the American Mathematical Society\n\n,\n\n(Aug\n\n).\n\n[2] Batyrev, V. V., and Cox, D. A. On the Hodge structure of projective hypersur- faces in toric varieties. Duke Mathematical Journal 75, 2 (Aug 1994).\n\n[\n\n] Bruzzo, U., and Montoya, W. On the Hodge conjecture for quasi-smooth in- tersections in toric varieties. S˜ao Paulo J. Math. Sci. Special Section: Geometry in Algebra and Algebra in Geometry (\n\n).\n\n[3] Bruzzo, U., and Montoya, W. On the Hodge conjecture for quasi-smooth in- tersections in toric varieties. S˜ao Paulo J. Math. Sci. Special Section: Geometry in Algebra and Algebra in Geometry (2021).\n\nA. R. Cohomology of complete intersections in toric varieties. Pub-', lookup_str='', metadata={'source': '/var/folders/ph/hhm7_zyx4l13k3v8z02dwp1w0000gn/T/tmpgq0ckaja/online_file.pdf'}, lookup_index=0)] This can be helpful for chunking texts semantically into sections as the output html content can be parsed via BeautifulSoup to get more structured and rich information about font size, page numbers, PDF headers/footers, etc. from langchain_community.docstore.document import Document cur_idx = -1 semantic_snippets = [] # Assumption: headings have higher font size than their respective content for s in snippets: # if current snippet's font size > previous section's heading => it is a new heading if not semantic_snippets or s[1] > semantic_snippets[cur_idx].metadata['heading_font']: metadata={'heading':s[0], 'content_font': 0, 'heading_font': s[1]} metadata.update(data.metadata) semantic_snippets.append(Document(page_content='',metadata=metadata)) cur_idx += 1 continue # if current snippet's font size <= previous section's content => content belongs to the same section (one can also create # a tree like structure for sub sections if needed but that may require some more thinking and may be data specific) if not semantic_snippets[cur_idx].metadata['content_font'] or s[1] <= semantic_snippets[cur_idx].metadata['content_font']: semantic_snippets[cur_idx].page_content += s[0] semantic_snippets[cur_idx].metadata['content_font'] = max(s[1], semantic_snippets[cur_idx].metadata['content_font']) continue # if current snippet's font size > previous section's content but less than previous section's heading than also make a new # section (e.g. title of a PDF will have the highest font size but we don't want it to subsume all sections) metadata={'heading':s[0], 'content_font': 0, 'heading_font': s[1]} metadata.update(data.metadata) semantic_snippets.append(Document(page_content='',metadata=metadata)) cur_idx += 1 Document(page_content='Recently, various DL models and datasets have been developed for layout analysis\ntasks. The dhSegment [22] utilizes fully convolutional networks [20] for segmen-\ntation tasks on historical documents. Object detection-based methods like Faster\nR-CNN [28] and Mask R-CNN [12] are used for identifying document elements [38]\nand detecting tables [30, 26]. Most recently, Graph Neural Networks [29] have also\nbeen used in table detection [27]. However, these models are usually implemented\nindividually and there is no unified framework to load and use such models.\nThere has been a surge of interest in creating open-source tools for document\nimage processing: a search of document image analysis in Github leads to 5M\nrelevant code pieces 6; yet most of them rely on traditional rule-based methods\nor provide limited functionalities. The closest prior research to our work is the\nOCR-D project7, which also tries to build a complete toolkit for DIA. However,\nsimilar to the platform developed by Neudecker et al. [21], it is designed for\nanalyzing historical documents, and provides no supports for recent DL models.\nThe DocumentLayoutAnalysis project8 focuses on processing born-digital PDF\ndocuments via analyzing the stored PDF data. Repositories like DeepLayout9\nand Detectron2-PubLayNet10 are individual deep learning models trained on\nlayout analysis datasets without support for the full DIA pipeline. The Document\nAnalysis and Exploitation (DAE) platform [15] and the DeepDIVA project [2]\naim to improve the reproducibility of DIA methods (or DL models), yet they\nare not actively maintained. OCR engines like Tesseract [14], easyOCR11 and\npaddleOCR12 usually do not come with comprehensive functionalities for other\nDIA tasks like layout analysis.\nRecent years have also seen numerous efforts to create libraries for promoting\nreproducibility and reusability in the field of DL. Libraries like Dectectron2 [35],\n6 The number shown is obtained by specifying the search type as ‘code’.\n7 https://ocr-d.de/en/about\n8 https://github.com/BobLd/DocumentLayoutAnalysis\n9 https://github.com/leonlulu/DeepLayout\n10 https://github.com/hpanwar08/detectron2\n11 https://github.com/JaidedAI/EasyOCR\n12 https://github.com/PaddlePaddle/PaddleOCR\n4\nZ. Shen et al.\nFig. 1: The overall architecture of LayoutParser. For an input document image,\nthe core LayoutParser library provides a set of off-the-shelf tools for layout\ndetection, OCR, visualization, and storage, backed by a carefully designed layout\ndata structure. LayoutParser also supports high level customization via efficient\nlayout annotation and model training functions. These improve model accuracy\non the target samples. The community platform enables the easy sharing of DIA\nmodels and whole digitization pipelines to promote reusability and reproducibility.\nA collection of detailed documentation, tutorials and exemplar projects make\nLayoutParser easy to learn and use.\nAllenNLP [8] and transformers [34] have provided the community with complete\nDL-based support for developing and deploying models for general computer\nvision and natural language processing problems. LayoutParser, on the other\nhand, specializes specifically in DIA tasks. LayoutParser is also equipped with a\ncommunity platform inspired by established model hubs such as Torch Hub [23]\nand TensorFlow Hub [1]. It enables the sharing of pretrained models as well as\nfull document processing pipelines that are unique to DIA tasks.\nThere have been a variety of document data collections to facilitate the\ndevelopment of DL models. Some examples include PRImA [3](magazine layouts),\nPubLayNet [38](academic paper layouts), Table Bank [18](tables in academic\npapers), Newspaper Navigator Dataset [16, 17](newspaper figure layouts) and\nHJDataset [31](historical Japanese document layouts). A spectrum of models\ntrained on these datasets are currently available in the LayoutParser model zoo\nto support different use cases.\n', metadata={'heading': '2 Related Work\n', 'content_font': 9, 'heading_font': 11, 'source': 'example_data/layout-parser-paper.pdf'}) This is the fastest of the PDF parsing options, and contains detailed metadata about the PDF and its pages, as well as returns one document per page. Document(page_content='LayoutParser: A Unified Toolkit for Deep\nLearning Based Document Image Analysis\nZejiang Shen1 (�), Ruochen Zhang2, Melissa Dell3, Benjamin Charles Germain\nLee4, Jacob Carlson3, and Weining Li5\n1 Allen Institute for AI\nshannons@allenai.org\n2 Brown University\nruochen zhang@brown.edu\n3 Harvard University\n{melissadell,jacob carlson}@fas.harvard.edu\n4 University of Washington\nbcgl@cs.washington.edu\n5 University of Waterloo\nw422li@uwaterloo.ca\nAbstract. Recent advances in document image analysis (DIA) have been\nprimarily driven by the application of neural networks. Ideally, research\noutcomes could be easily deployed in production and extended for further\ninvestigation. However, various factors like loosely organized codebases\nand sophisticated model configurations complicate the easy reuse of im-\nportant innovations by a wide audience. Though there have been on-going\nefforts to improve reusability and simplify deep learning (DL) model\ndevelopment in disciplines like natural language processing and computer\nvision, none of them are optimized for challenges in the domain of DIA.\nThis represents a major gap in the existing toolkit, as DIA is central to\nacademic research across a wide range of disciplines in the social sciences\nand humanities. This paper introduces LayoutParser, an open-source\nlibrary for streamlining the usage of DL in DIA research and applica-\ntions. The core LayoutParser library comes with a set of simple and\nintuitive interfaces for applying and customizing DL models for layout de-\ntection, character recognition, and many other document processing tasks.\nTo promote extensibility, LayoutParser also incorporates a community\nplatform for sharing both pre-trained models and full document digiti-\nzation pipelines. We demonstrate that LayoutParser is helpful for both\nlightweight and large-scale digitization pipelines in real-word use cases.\nThe library is publicly available at https://layout-parser.github.io.\nKeywords: Document Image Analysis · Deep Learning · Layout Analysis\n· Character Recognition · Open Source library · Toolkit.\n1\nIntroduction\nDeep Learning(DL)-based approaches are the state-of-the-art for a wide range of\ndocument image analysis (DIA) tasks including document image classification [11,\narXiv:2103.15348v2 [cs.CV] 21 Jun 2021\n', lookup_str='', metadata={'file_path': 'example_data/layout-parser-paper.pdf', 'page_number': 1, 'total_pages': 16, 'format': 'PDF 1.5', 'title': '', 'author': '', 'subject': '', 'keywords': '', 'creator': 'LaTeX with hyperref', 'producer': 'pdfTeX-1.40.21', 'creationDate': 'D:20210622012710Z', 'modDate': 'D:20210622012710Z', 'trapped': '', 'encryption': None}, lookup_index=0) Additionally, you can pass along any of the options from the PyMuPDF documentation as keyword arguments in the load call, and it will be pass along to the get_text() call. Like PyMuPDF, the output Documents contain detailed metadata about the PDF and its pages, and returns one document per page. Document(page_content='LayoutParser: A Unified Toolkit for Deep\nLearning Based Document Image Analysis\nZejiang Shen1 ((cid:0)), Ruochen Zhang2, Melissa Dell3, Benjamin Charles Germain\nLee4, Jacob Carlson3, and Weining Li5\n1 Allen Institute for AI\n1202 shannons@allenai.org\n2 Brown University\nruochen zhang@brown.edu\n3 Harvard University\nnuJ {melissadell,jacob carlson}@fas.harvard.edu\n4 University of Washington\nbcgl@cs.washington.edu\n12 5 University of Waterloo\nw422li@uwaterloo.ca\n]VC.sc[\nAbstract. Recentadvancesindocumentimageanalysis(DIA)havebeen\nprimarily driven by the application of neural networks. Ideally, research\noutcomescouldbeeasilydeployedinproductionandextendedforfurther\ninvestigation. However, various factors like loosely organized codebases\nand sophisticated model configurations complicate the easy reuse of im-\n2v84351.3012:viXra portantinnovationsbyawideaudience.Thoughtherehavebeenon-going\nefforts to improve reusability and simplify deep learning (DL) model\ndevelopmentindisciplineslikenaturallanguageprocessingandcomputer\nvision, none of them are optimized for challenges in the domain of DIA.\nThis represents a major gap in the existing toolkit, as DIA is central to\nacademicresearchacross awiderangeof disciplinesinthesocialsciences\nand humanities. This paper introduces LayoutParser, an open-source\nlibrary for streamlining the usage of DL in DIA research and applica-\ntions. The core LayoutParser library comes with a set of simple and\nintuitiveinterfacesforapplyingandcustomizingDLmodelsforlayoutde-\ntection,characterrecognition,andmanyotherdocumentprocessingtasks.\nTo promote extensibility, LayoutParser also incorporates a community\nplatform for sharing both pre-trained models and full document digiti-\nzation pipelines. We demonstrate that LayoutParser is helpful for both\nlightweight and large-scale digitization pipelines in real-word use cases.\nThe library is publicly available at https://layout-parser.github.io.\nKeywords: DocumentImageAnalysis·DeepLearning·LayoutAnalysis\n· Character Recognition · Open Source library · Toolkit.\n1 Introduction\nDeep Learning(DL)-based approaches are the state-of-the-art for a wide range of\ndocumentimageanalysis(DIA)tasksincludingdocumentimageclassification[11,', metadata={'source': 'example_data/layout-parser-paper.pdf', 'file_path': 'example_data/layout-parser-paper.pdf', 'page': 1, 'total_pages': 16, 'Author': '', 'CreationDate': 'D:20210622012710Z', 'Creator': 'LaTeX with hyperref', 'Keywords': '', 'ModDate': 'D:20210622012710Z', 'PTEX.Fullbanner': 'This is pdfTeX, Version 3.14159265-2.6-1.40.21 (TeX Live 2020) kpathsea version 6.3.2', 'Producer': 'pdfTeX-1.40.21', 'Subject': '', 'Title': '', 'Trapped': 'False'}) The AmazonTextractPDFLoader calls the Amazon Textract Service to convert PDFs into a Document structure. The loader does pure OCR at the moment, with more features like layout support planned, depending on demand. Single and multi-page documents are supported with up to 3000 pages and 512 MB of size. For the call to be successful an AWS account is required, similar to the AWS CLI requirements. Besides the AWS configuration, it is very similar to the other PDF loaders, while also supporting JPEG, PNG and TIFF and non-native PDF formats. Azure AI Document Intelligence (formerly known as Azure Form Recognizer) is machine-learning based service that extracts texts (including handwriting), tables, document structures (e.g., titles, section headings, etc.) and key-value-pairs from digital or scanned PDFs, images, Office and HTML files. Document Intelligence supports PDF, JPEG/JPG, PNG, BMP, TIFF, HEIF, DOCX, XLSX, PPTX and HTML. This current implementation of a loader using Document Intelligence can incorporate content page-wise and turn it into LangChain documents. The default output format is markdown, which can be easily chained with MarkdownHeaderTextSplitter for semantic document chunking. You can also use mode="single" or mode="page" to return pure texts in a single page or document split by page. An Azure AI Document Intelligence resource in one of the 3 preview regions: East US, West US2, West Europe - follow this document to create one if you don't have. You will be passing <endpoint> and <key> as parameters to the loader.

https://python.langchain.com/docs/modules/agents/how_to/agent_structured/

## Returning Structured Output This notebook covers how to have an agent return a structured output. By default, most of the agents return a single string. It can often be useful to have an agent return something with more structure. A good example of this is an agent tasked with doing question-answering over some sources. Let’s say we want the agent to respond not only with the answer, but also a list of the sources used. We then want our output to roughly follow the schema below: ``` class Response(BaseModel): """Final response to the question being asked""" answer: str = Field(description = "The final answer to respond to the user") sources: List[int] = Field(description="List of page chunks that contain answer to the question. Only include a page chunk if it contains relevant information") ``` In this notebook we will go over an agent that has a retriever tool and responds in the correct format. ## Create the Retriever[​](#create-the-retriever "Direct link to Create the Retriever") In this section we will do some setup work to create our retriever over some mock data containing the “State of the Union” address. Importantly, we will add a “page\_chunk” tag to the metadata of each document. This is just some fake data intended to simulate a source field. In practice, this would more likely be the URL or path of a document. ``` %pip install -qU langchain langchain-community langchain-openai langchain-chroma ``` ``` from langchain_chroma import Chromafrom langchain_community.document_loaders import TextLoaderfrom langchain_openai import OpenAIEmbeddingsfrom langchain_text_splitters import RecursiveCharacterTextSplitter ``` ``` # Load in document to retrieve overloader = TextLoader("../../state_of_the_union.txt")documents = loader.load()# Split document into chunkstext_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=0)texts = text_splitter.split_documents(documents)# Here is where we add in the fake source informationfor i, doc in enumerate(texts): doc.metadata["page_chunk"] = i# Create our retrieverembeddings = OpenAIEmbeddings()vectorstore = Chroma.from_documents(texts, embeddings, collection_name="state-of-union")retriever = vectorstore.as_retriever() ``` We will now create the tools we want to give to the agent. In this case, it is just one - a tool that wraps our retriever. ``` from langchain.tools.retriever import create_retriever_toolretriever_tool = create_retriever_tool( retriever, "state-of-union-retriever", "Query a retriever to get information about state of the union address",) ``` ## Create response schema[​](#create-response-schema "Direct link to Create response schema") Here is where we will define the response schema. In this case, we want the final answer to have two fields: one for the `answer`, and then another that is a list of `sources` ``` from typing import Listfrom langchain_core.pydantic_v1 import BaseModel, Fieldclass Response(BaseModel): """Final response to the question being asked""" answer: str = Field(description="The final answer to respond to the user") sources: List[int] = Field( description="List of page chunks that contain answer to the question. Only include a page chunk if it contains relevant information" ) ``` ## Create the custom parsing logic[​](#create-the-custom-parsing-logic "Direct link to Create the custom parsing logic") We now create some custom parsing logic. How this works is that we will pass the `Response` schema to the OpenAI LLM via their `functions` parameter. This is similar to how we pass tools for the agent to use. When the `Response` function is called by OpenAI, we want to use that as a signal to return to the user. When any other function is called by OpenAI, we treat that as a tool invocation. Therefore, our parsing logic has the following blocks: * If no function is called, assume that we should use the response to respond to the user, and therefore return `AgentFinish` * If the `Response` function is called, respond to the user with the inputs to that function (our structured output), and therefore return `AgentFinish` * If any other function is called, treat that as a tool invocation, and therefore return `AgentActionMessageLog` Note that we are using `AgentActionMessageLog` rather than `AgentAction` because it lets us attach a log of messages that we can use in the future to pass back into the agent prompt. ``` import jsonfrom langchain_core.agents import AgentActionMessageLog, AgentFinish ``` ``` def parse(output): # If no function was invoked, return to user if "function_call" not in output.additional_kwargs: return AgentFinish(return_values={"output": output.content}, log=output.content) # Parse out the function call function_call = output.additional_kwargs["function_call"] name = function_call["name"] inputs = json.loads(function_call["arguments"]) # If the Response function was invoked, return to the user with the function inputs if name == "Response": return AgentFinish(return_values=inputs, log=str(function_call)) # Otherwise, return an agent action else: return AgentActionMessageLog( tool=name, tool_input=inputs, log="", message_log=[output] ) ``` ## Create the Agent[​](#create-the-agent "Direct link to Create the Agent") We can now put this all together! The components of this agent are: * prompt: a simple prompt with placeholders for the user’s question and then the `agent_scratchpad` (any intermediate steps) * tools: we can attach the tools and `Response` format to the LLM as functions * format scratchpad: in order to format the `agent_scratchpad` from intermediate steps, we will use the standard `format_to_openai_function_messages`. This takes intermediate steps and formats them as AIMessages and FunctionMessages. * output parser: we will use our custom parser above to parse the response of the LLM * AgentExecutor: we will use the standard AgentExecutor to run the loop of agent-tool-agent-tool… ``` from langchain.agents import AgentExecutorfrom langchain.agents.format_scratchpad import format_to_openai_function_messagesfrom langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholderfrom langchain_openai import ChatOpenAI ``` ``` prompt = ChatPromptTemplate.from_messages( [ ("system", "You are a helpful assistant"), ("user", "{input}"), MessagesPlaceholder(variable_name="agent_scratchpad"), ]) ``` ``` llm = ChatOpenAI(temperature=0) ``` ``` llm_with_tools = llm.bind_functions([retriever_tool, Response]) ``` ``` agent = ( { "input": lambda x: x["input"], # Format agent scratchpad from intermediate steps "agent_scratchpad": lambda x: format_to_openai_function_messages( x["intermediate_steps"] ), } | prompt | llm_with_tools | parse) ``` ``` agent_executor = AgentExecutor(tools=[retriever_tool], agent=agent, verbose=True) ``` ## Run the agent[​](#run-the-agent "Direct link to Run the agent") We can now run the agent! Notice how it responds with a dictionary with two keys: `answer` and `sources` ``` agent_executor.invoke( {"input": "what did the president say about ketanji brown jackson"}, return_only_outputs=True,) ``` ``` > Entering new AgentExecutor chain...Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.And for our LGBTQ+ Americans, let’s finally get the bipartisan Equality Act to my desk. The onslaught of state laws targeting transgender Americans and their families is wrong. As I said last year, especially to our younger transgender Americans, I will always have your back as your President, so you can be yourself and reach your God-given potential. While it often appears that we never agree, that isn’t true. I signed 80 bipartisan bills into law last year. From preventing government shutdowns to protecting Asian-Americans from still-too-common hate crimes to reforming military justice. And soon, we’ll strengthen the Violence Against Women Act that I first wrote three decades ago. It is important for us to show the nation that we can come together and do big things. So tonight I’m offering a Unity Agenda for the Nation. Four big things we can do together. First, beat the opioid epidemic.Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. Last year COVID-19 kept us apart. This year we are finally together again. Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. With a duty to one another to the American people to the Constitution. And with an unwavering resolve that freedom will always triumph over tyranny. Six days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. He thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. He met the Ukrainian people. From President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world.A former top litigator in private practice. A former federal public defender. And from a family of public school educators and police officers. A consensus builder. Since she’s been nominated, she’s received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans. And if we are to advance liberty and justice, we need to secure the Border and fix the immigration system. We can do both. At our border, we’ve installed new technology like cutting-edge scanners to better detect drug smuggling. We’ve set up joint patrols with Mexico and Guatemala to catch more human traffickers. We’re putting in place dedicated immigration judges so families fleeing persecution and violence can have their cases heard faster. We’re securing commitments and supporting partners in South and Central America to host more refugees and secure their own borders.{'arguments': '{\n"answer": "President Biden nominated Ketanji Brown Jackson for the United States Supreme Court and described her as one of our nation\'s top legal minds who will continue Justice Breyer\'s legacy of excellence.",\n"sources": [6]\n}', 'name': 'Response'}> Finished chain. ``` ``` {'answer': "President Biden nominated Ketanji Brown Jackson for the United States Supreme Court and described her as one of our nation's top legal minds who will continue Justice Breyer's legacy of excellence.", 'sources': [6]} ```

Returning Structured Output This notebook covers how to have an agent return a structured output. By default, most of the agents return a single string. It can often be useful to have an agent return something with more structure. A good example of this is an agent tasked with doing question-answering over some sources. Let’s say we want the agent to respond not only with the answer, but also a list of the sources used. We then want our output to roughly follow the schema below: class Response(BaseModel): """Final response to the question being asked""" answer: str = Field(description = "The final answer to respond to the user") sources: List[int] = Field(description="List of page chunks that contain answer to the question. Only include a page chunk if it contains relevant information") In this notebook we will go over an agent that has a retriever tool and responds in the correct format. Create the Retriever​ In this section we will do some setup work to create our retriever over some mock data containing the “State of the Union” address. Importantly, we will add a “page_chunk” tag to the metadata of each document. This is just some fake data intended to simulate a source field. In practice, this would more likely be the URL or path of a document. %pip install -qU langchain langchain-community langchain-openai langchain-chroma from langchain_chroma import Chroma from langchain_community.document_loaders import TextLoader from langchain_openai import OpenAIEmbeddings from langchain_text_splitters import RecursiveCharacterTextSplitter # Load in document to retrieve over loader = TextLoader("../../state_of_the_union.txt") documents = loader.load() # Split document into chunks text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=0) texts = text_splitter.split_documents(documents) # Here is where we add in the fake source information for i, doc in enumerate(texts): doc.metadata["page_chunk"] = i # Create our retriever embeddings = OpenAIEmbeddings() vectorstore = Chroma.from_documents(texts, embeddings, collection_name="state-of-union") retriever = vectorstore.as_retriever() We will now create the tools we want to give to the agent. In this case, it is just one - a tool that wraps our retriever. from langchain.tools.retriever import create_retriever_tool retriever_tool = create_retriever_tool( retriever, "state-of-union-retriever", "Query a retriever to get information about state of the union address", ) Create response schema​ Here is where we will define the response schema. In this case, we want the final answer to have two fields: one for the answer, and then another that is a list of sources from typing import List from langchain_core.pydantic_v1 import BaseModel, Field class Response(BaseModel): """Final response to the question being asked""" answer: str = Field(description="The final answer to respond to the user") sources: List[int] = Field( description="List of page chunks that contain answer to the question. Only include a page chunk if it contains relevant information" ) Create the custom parsing logic​ We now create some custom parsing logic. How this works is that we will pass the Response schema to the OpenAI LLM via their functions parameter. This is similar to how we pass tools for the agent to use. When the Response function is called by OpenAI, we want to use that as a signal to return to the user. When any other function is called by OpenAI, we treat that as a tool invocation. Therefore, our parsing logic has the following blocks: If no function is called, assume that we should use the response to respond to the user, and therefore return AgentFinish If the Response function is called, respond to the user with the inputs to that function (our structured output), and therefore return AgentFinish If any other function is called, treat that as a tool invocation, and therefore return AgentActionMessageLog Note that we are using AgentActionMessageLog rather than AgentAction because it lets us attach a log of messages that we can use in the future to pass back into the agent prompt. import json from langchain_core.agents import AgentActionMessageLog, AgentFinish def parse(output): # If no function was invoked, return to user if "function_call" not in output.additional_kwargs: return AgentFinish(return_values={"output": output.content}, log=output.content) # Parse out the function call function_call = output.additional_kwargs["function_call"] name = function_call["name"] inputs = json.loads(function_call["arguments"]) # If the Response function was invoked, return to the user with the function inputs if name == "Response": return AgentFinish(return_values=inputs, log=str(function_call)) # Otherwise, return an agent action else: return AgentActionMessageLog( tool=name, tool_input=inputs, log="", message_log=[output] ) Create the Agent​ We can now put this all together! The components of this agent are: prompt: a simple prompt with placeholders for the user’s question and then the agent_scratchpad (any intermediate steps) tools: we can attach the tools and Response format to the LLM as functions format scratchpad: in order to format the agent_scratchpad from intermediate steps, we will use the standard format_to_openai_function_messages. This takes intermediate steps and formats them as AIMessages and FunctionMessages. output parser: we will use our custom parser above to parse the response of the LLM AgentExecutor: we will use the standard AgentExecutor to run the loop of agent-tool-agent-tool… from langchain.agents import AgentExecutor from langchain.agents.format_scratchpad import format_to_openai_function_messages from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder from langchain_openai import ChatOpenAI prompt = ChatPromptTemplate.from_messages( [ ("system", "You are a helpful assistant"), ("user", "{input}"), MessagesPlaceholder(variable_name="agent_scratchpad"), ] ) llm = ChatOpenAI(temperature=0) llm_with_tools = llm.bind_functions([retriever_tool, Response]) agent = ( { "input": lambda x: x["input"], # Format agent scratchpad from intermediate steps "agent_scratchpad": lambda x: format_to_openai_function_messages( x["intermediate_steps"] ), } | prompt | llm_with_tools | parse ) agent_executor = AgentExecutor(tools=[retriever_tool], agent=agent, verbose=True) Run the agent​ We can now run the agent! Notice how it responds with a dictionary with two keys: answer and sources agent_executor.invoke( {"input": "what did the president say about ketanji brown jackson"}, return_only_outputs=True, ) > Entering new AgentExecutor chain... Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. And for our LGBTQ+ Americans, let’s finally get the bipartisan Equality Act to my desk. The onslaught of state laws targeting transgender Americans and their families is wrong. As I said last year, especially to our younger transgender Americans, I will always have your back as your President, so you can be yourself and reach your God-given potential. While it often appears that we never agree, that isn’t true. I signed 80 bipartisan bills into law last year. From preventing government shutdowns to protecting Asian-Americans from still-too-common hate crimes to reforming military justice. And soon, we’ll strengthen the Violence Against Women Act that I first wrote three decades ago. It is important for us to show the nation that we can come together and do big things. So tonight I’m offering a Unity Agenda for the Nation. Four big things we can do together. First, beat the opioid epidemic. Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. Last year COVID-19 kept us apart. This year we are finally together again. Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. With a duty to one another to the American people to the Constitution. And with an unwavering resolve that freedom will always triumph over tyranny. Six days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. He thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. He met the Ukrainian people. From President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world. A former top litigator in private practice. A former federal public defender. And from a family of public school educators and police officers. A consensus builder. Since she’s been nominated, she’s received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans. And if we are to advance liberty and justice, we need to secure the Border and fix the immigration system. We can do both. At our border, we’ve installed new technology like cutting-edge scanners to better detect drug smuggling. We’ve set up joint patrols with Mexico and Guatemala to catch more human traffickers. We’re putting in place dedicated immigration judges so families fleeing persecution and violence can have their cases heard faster. We’re securing commitments and supporting partners in South and Central America to host more refugees and secure their own borders.{'arguments': '{\n"answer": "President Biden nominated Ketanji Brown Jackson for the United States Supreme Court and described her as one of our nation\'s top legal minds who will continue Justice Breyer\'s legacy of excellence.",\n"sources": [6]\n}', 'name': 'Response'} > Finished chain. {'answer': "President Biden nominated Ketanji Brown Jackson for the United States Supreme Court and described her as one of our nation's top legal minds who will continue Justice Breyer's legacy of excellence.", 'sources': [6]}

https://python.langchain.com/docs/modules/agents/how_to/custom_agent/

## Custom agent This notebook goes through how to create your own custom agent. In this example, we will use OpenAI Tool Calling to create this agent. **This is generally the most reliable way to create agents.** We will first create it WITHOUT memory, but we will then show how to add memory in. Memory is needed to enable conversation. ## Load the LLM[​](#load-the-llm "Direct link to Load the LLM") First, let’s load the language model we’re going to use to control the agent. ``` from langchain_openai import ChatOpenAIllm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0) ``` Next, let’s define some tools to use. Let’s write a really simple Python function to calculate the length of a word that is passed in. Note that here the function docstring that we use is pretty important. Read more about why this is the case [here](https://python.langchain.com/docs/modules/tools/custom_tools/) ``` from langchain.agents import tool@tooldef get_word_length(word: str) -> int: """Returns the length of a word.""" return len(word)get_word_length.invoke("abc") ``` ``` tools = [get_word_length] ``` ## Create Prompt[​](#create-prompt "Direct link to Create Prompt") Now let us create the prompt. Because OpenAI Function Calling is finetuned for tool usage, we hardly need any instructions on how to reason, or how to output format. We will just have two input variables: `input` and `agent_scratchpad`. `input` should be a string containing the user objective. `agent_scratchpad` should be a sequence of messages that contains the previous agent tool invocations and the corresponding tool outputs. ``` from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholderprompt = ChatPromptTemplate.from_messages( [ ( "system", "You are very powerful assistant, but don't know current events", ), ("user", "{input}"), MessagesPlaceholder(variable_name="agent_scratchpad"), ]) ``` How does the agent know what tools it can use? In this case we’re relying on OpenAI tool calling LLMs, which take tools as a separate argument and have been specifically trained to know when to invoke those tools. To pass in our tools to the agent, we just need to format them to the [OpenAI tool format](https://platform.openai.com/docs/api-reference/chat/create) and pass them to our model. (By `bind`\-ing the functions, we’re making sure that they’re passed in each time the model is invoked.) ``` llm_with_tools = llm.bind_tools(tools) ``` ## Create the Agent[​](#create-the-agent "Direct link to Create the Agent") Putting those pieces together, we can now create the agent. We will import two last utility functions: a component for formatting intermediate steps (agent action, tool output pairs) to input messages that can be sent to the model, and a component for converting the output message into an agent action/agent finish. ``` from langchain.agents.format_scratchpad.openai_tools import ( format_to_openai_tool_messages,)from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParseragent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: format_to_openai_tool_messages( x["intermediate_steps"] ), } | prompt | llm_with_tools | OpenAIToolsAgentOutputParser()) ``` ``` from langchain.agents import AgentExecutoragent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) ``` ``` list(agent_executor.stream({"input": "How many letters in the word eudca"})) ``` ``` > Entering new AgentExecutor chain...Invoking: `get_word_length` with `{'word': 'eudca'}`5There are 5 letters in the word "eudca".> Finished chain. ``` ``` [{'actions': [OpenAIToolAgentAction(tool='get_word_length', tool_input={'word': 'eudca'}, log="\nInvoking: `get_word_length` with `{'word': 'eudca'}`\n\n\n", message_log=[AIMessageChunk(content='', additional_kwargs={'tool_calls': [{'index': 0, 'id': 'call_A07D5TuyqcNIL0DIEVRPpZkg', 'function': {'arguments': '{\n "word": "eudca"\n}', 'name': 'get_word_length'}, 'type': 'function'}]})], tool_call_id='call_A07D5TuyqcNIL0DIEVRPpZkg')], 'messages': [AIMessageChunk(content='', additional_kwargs={'tool_calls': [{'index': 0, 'id': 'call_A07D5TuyqcNIL0DIEVRPpZkg', 'function': {'arguments': '{\n "word": "eudca"\n}', 'name': 'get_word_length'}, 'type': 'function'}]})]}, {'steps': [AgentStep(action=OpenAIToolAgentAction(tool='get_word_length', tool_input={'word': 'eudca'}, log="\nInvoking: `get_word_length` with `{'word': 'eudca'}`\n\n\n", message_log=[AIMessageChunk(content='', additional_kwargs={'tool_calls': [{'index': 0, 'id': 'call_A07D5TuyqcNIL0DIEVRPpZkg', 'function': {'arguments': '{\n "word": "eudca"\n}', 'name': 'get_word_length'}, 'type': 'function'}]})], tool_call_id='call_A07D5TuyqcNIL0DIEVRPpZkg'), observation=5)], 'messages': [FunctionMessage(content='5', name='get_word_length')]}, {'output': 'There are 5 letters in the word "eudca".', 'messages': [AIMessage(content='There are 5 letters in the word "eudca".')]}] ``` If we compare this to the base LLM, we can see that the LLM alone struggles ``` llm.invoke("How many letters in the word educa") ``` ``` AIMessage(content='There are 6 letters in the word "educa".') ``` ## Adding memory[​](#adding-memory "Direct link to Adding memory") This is great - we have an agent! However, this agent is stateless - it doesn’t remember anything about previous interactions. This means you can’t ask follow up questions easily. Let’s fix that by adding in memory. In order to do this, we need to do two things: 1. Add a place for memory variables to go in the prompt 2. Keep track of the chat history First, let’s add a place for memory in the prompt. We do this by adding a placeholder for messages with the key `"chat_history"`. Notice that we put this ABOVE the new user input (to follow the conversation flow). ``` from langchain_core.prompts import MessagesPlaceholderMEMORY_KEY = "chat_history"prompt = ChatPromptTemplate.from_messages( [ ( "system", "You are very powerful assistant, but bad at calculating lengths of words.", ), MessagesPlaceholder(variable_name=MEMORY_KEY), ("user", "{input}"), MessagesPlaceholder(variable_name="agent_scratchpad"), ]) ``` We can then set up a list to track the chat history ``` from langchain_core.messages import AIMessage, HumanMessagechat_history = [] ``` We can then put it all together! ``` agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: format_to_openai_tool_messages( x["intermediate_steps"] ), "chat_history": lambda x: x["chat_history"], } | prompt | llm_with_tools | OpenAIToolsAgentOutputParser())agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) ``` When running, we now need to track the inputs and outputs as chat history ``` input1 = "how many letters in the word educa?"result = agent_executor.invoke({"input": input1, "chat_history": chat_history})chat_history.extend( [ HumanMessage(content=input1), AIMessage(content=result["output"]), ])agent_executor.invoke({"input": "is that a real word?", "chat_history": chat_history}) ``` ``` > Entering new AgentExecutor chain...Invoking: `get_word_length` with `{'word': 'educa'}`5There are 5 letters in the word "educa".> Finished chain.> Entering new AgentExecutor chain...No, "educa" is not a real word in English.> Finished chain. ``` ``` {'input': 'is that a real word?', 'chat_history': [HumanMessage(content='how many letters in the word educa?'), AIMessage(content='There are 5 letters in the word "educa".')], 'output': 'No, "educa" is not a real word in English.'} ```

Custom agent This notebook goes through how to create your own custom agent. In this example, we will use OpenAI Tool Calling to create this agent. This is generally the most reliable way to create agents. We will first create it WITHOUT memory, but we will then show how to add memory in. Memory is needed to enable conversation. Load the LLM​ First, let’s load the language model we’re going to use to control the agent. from langchain_openai import ChatOpenAI llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0) Next, let’s define some tools to use. Let’s write a really simple Python function to calculate the length of a word that is passed in. Note that here the function docstring that we use is pretty important. Read more about why this is the case here from langchain.agents import tool @tool def get_word_length(word: str) -> int: """Returns the length of a word.""" return len(word) get_word_length.invoke("abc") tools = [get_word_length] Create Prompt​ Now let us create the prompt. Because OpenAI Function Calling is finetuned for tool usage, we hardly need any instructions on how to reason, or how to output format. We will just have two input variables: input and agent_scratchpad. input should be a string containing the user objective. agent_scratchpad should be a sequence of messages that contains the previous agent tool invocations and the corresponding tool outputs. from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder prompt = ChatPromptTemplate.from_messages( [ ( "system", "You are very powerful assistant, but don't know current events", ), ("user", "{input}"), MessagesPlaceholder(variable_name="agent_scratchpad"), ] ) How does the agent know what tools it can use? In this case we’re relying on OpenAI tool calling LLMs, which take tools as a separate argument and have been specifically trained to know when to invoke those tools. To pass in our tools to the agent, we just need to format them to the OpenAI tool format and pass them to our model. (By bind-ing the functions, we’re making sure that they’re passed in each time the model is invoked.) llm_with_tools = llm.bind_tools(tools) Create the Agent​ Putting those pieces together, we can now create the agent. We will import two last utility functions: a component for formatting intermediate steps (agent action, tool output pairs) to input messages that can be sent to the model, and a component for converting the output message into an agent action/agent finish. from langchain.agents.format_scratchpad.openai_tools import ( format_to_openai_tool_messages, ) from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: format_to_openai_tool_messages( x["intermediate_steps"] ), } | prompt | llm_with_tools | OpenAIToolsAgentOutputParser() ) from langchain.agents import AgentExecutor agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) list(agent_executor.stream({"input": "How many letters in the word eudca"})) > Entering new AgentExecutor chain... Invoking: `get_word_length` with `{'word': 'eudca'}` 5There are 5 letters in the word "eudca". > Finished chain. [{'actions': [OpenAIToolAgentAction(tool='get_word_length', tool_input={'word': 'eudca'}, log="\nInvoking: `get_word_length` with `{'word': 'eudca'}`\n\n\n", message_log=[AIMessageChunk(content='', additional_kwargs={'tool_calls': [{'index': 0, 'id': 'call_A07D5TuyqcNIL0DIEVRPpZkg', 'function': {'arguments': '{\n "word": "eudca"\n}', 'name': 'get_word_length'}, 'type': 'function'}]})], tool_call_id='call_A07D5TuyqcNIL0DIEVRPpZkg')], 'messages': [AIMessageChunk(content='', additional_kwargs={'tool_calls': [{'index': 0, 'id': 'call_A07D5TuyqcNIL0DIEVRPpZkg', 'function': {'arguments': '{\n "word": "eudca"\n}', 'name': 'get_word_length'}, 'type': 'function'}]})]}, {'steps': [AgentStep(action=OpenAIToolAgentAction(tool='get_word_length', tool_input={'word': 'eudca'}, log="\nInvoking: `get_word_length` with `{'word': 'eudca'}`\n\n\n", message_log=[AIMessageChunk(content='', additional_kwargs={'tool_calls': [{'index': 0, 'id': 'call_A07D5TuyqcNIL0DIEVRPpZkg', 'function': {'arguments': '{\n "word": "eudca"\n}', 'name': 'get_word_length'}, 'type': 'function'}]})], tool_call_id='call_A07D5TuyqcNIL0DIEVRPpZkg'), observation=5)], 'messages': [FunctionMessage(content='5', name='get_word_length')]}, {'output': 'There are 5 letters in the word "eudca".', 'messages': [AIMessage(content='There are 5 letters in the word "eudca".')]}] If we compare this to the base LLM, we can see that the LLM alone struggles llm.invoke("How many letters in the word educa") AIMessage(content='There are 6 letters in the word "educa".') Adding memory​ This is great - we have an agent! However, this agent is stateless - it doesn’t remember anything about previous interactions. This means you can’t ask follow up questions easily. Let’s fix that by adding in memory. In order to do this, we need to do two things: Add a place for memory variables to go in the prompt Keep track of the chat history First, let’s add a place for memory in the prompt. We do this by adding a placeholder for messages with the key "chat_history". Notice that we put this ABOVE the new user input (to follow the conversation flow). from langchain_core.prompts import MessagesPlaceholder MEMORY_KEY = "chat_history" prompt = ChatPromptTemplate.from_messages( [ ( "system", "You are very powerful assistant, but bad at calculating lengths of words.", ), MessagesPlaceholder(variable_name=MEMORY_KEY), ("user", "{input}"), MessagesPlaceholder(variable_name="agent_scratchpad"), ] ) We can then set up a list to track the chat history from langchain_core.messages import AIMessage, HumanMessage chat_history = [] We can then put it all together! agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: format_to_openai_tool_messages( x["intermediate_steps"] ), "chat_history": lambda x: x["chat_history"], } | prompt | llm_with_tools | OpenAIToolsAgentOutputParser() ) agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) When running, we now need to track the inputs and outputs as chat history input1 = "how many letters in the word educa?" result = agent_executor.invoke({"input": input1, "chat_history": chat_history}) chat_history.extend( [ HumanMessage(content=input1), AIMessage(content=result["output"]), ] ) agent_executor.invoke({"input": "is that a real word?", "chat_history": chat_history}) > Entering new AgentExecutor chain... Invoking: `get_word_length` with `{'word': 'educa'}` 5There are 5 letters in the word "educa". > Finished chain. > Entering new AgentExecutor chain... No, "educa" is not a real word in English. > Finished chain. {'input': 'is that a real word?', 'chat_history': [HumanMessage(content='how many letters in the word educa?'), AIMessage(content='There are 5 letters in the word "educa".')], 'output': 'No, "educa" is not a real word in English.'}

https://python.langchain.com/docs/modules/data_connection/document_transformers/

## Text Splitters Once you've loaded documents, you'll often want to transform them to better suit your application. The simplest example is you may want to split a long document into smaller chunks that can fit into your model's context window. LangChain has a number of built-in document transformers that make it easy to split, combine, filter, and otherwise manipulate documents. When you want to deal with long pieces of text, it is necessary to split up that text into chunks. As simple as this sounds, there is a lot of potential complexity here. Ideally, you want to keep the semantically related pieces of text together. What "semantically related" means could depend on the type of text. This notebook showcases several ways to do that. At a high level, text splitters work as following: 1. Split the text up into small, semantically meaningful chunks (often sentences). 2. Start combining these small chunks into a larger chunk until you reach a certain size (as measured by some function). 3. Once you reach that size, make that chunk its own piece of text and then start creating a new chunk of text with some overlap (to keep context between chunks). That means there are two different axes along which you can customize your text splitter: 1. How the text is split 2. How the chunk size is measured ## Types of Text Splitters[​](#types-of-text-splitters "Direct link to Types of Text Splitters") LangChain offers many different types of text splitters. These all live in the `langchain-text-splitters` package. Below is a table listing all of them, along with a few characteristics: **Name**: Name of the text splitter **Splits On**: How this text splitter splits text **Adds Metadata**: Whether or not this text splitter adds metadata about where each chunk came from. **Description**: Description of the splitter, including recommendation on when to use it. | Name | Splits On | Adds Metadata | Description | | --- | --- | --- | --- | | Recursive | A list of user defined characters | | Recursively splits text. Splitting text recursively serves the purpose of trying to keep related pieces of text next to each other. This is the recommended way to start splitting text. | | HTML | HTML specific characters | ✅ | Splits text based on HTML-specific characters. Notably, this adds in relevant information about where that chunk came from (based on the HTML) | | Markdown | Markdown specific characters | ✅ | Splits text based on Markdown-specific characters. Notably, this adds in relevant information about where that chunk came from (based on the Markdown) | | Code | Code (Python, JS) specific characters | | Splits text based on characters specific to coding languages. 15 different languages are available to choose from. | | Token | Tokens | | Splits text on tokens. There exist a few different ways to measure tokens. | | Character | A user defined character | | Splits text based on a user defined character. One of the simpler methods. | | \[Experimental\] Semantic Chunker | Sentences | | First splits on sentences. Then combines ones next to each other if they are semantically similar enough. Taken from [Greg Kamradt](https://github.com/FullStackRetrieval-com/RetrievalTutorials/blob/main/tutorials/LevelsOfTextSplitting/5_Levels_Of_Text_Splitting.ipynb) | | [AI21 Semantic Text Splitter](https://python.langchain.com/docs/integrations/document_transformers/ai21_semantic_text_splitter/) | Semantics | ✅ | Identifies distinct topics that form coherent pieces of text and splits along those. | ## Evaluate text splitters[​](#evaluate-text-splitters "Direct link to Evaluate text splitters") You can evaluate text splitters with the [Chunkviz utility](https://www.chunkviz.com/) created by `Greg Kamradt`. `Chunkviz` is a great tool for visualizing how your text splitter is working. It will show you how your text is being split up and help in tuning up the splitting parameters. ## Other Document Transforms[​](#other-document-transforms "Direct link to Other Document Transforms") Text splitting is only one example of transformations that you may want to do on documents before passing them to an LLM. Head to [Integrations](https://python.langchain.com/docs/integrations/document_transformers/) for documentation on built-in document transformer integrations with 3rd-party tools.

Text Splitters Once you've loaded documents, you'll often want to transform them to better suit your application. The simplest example is you may want to split a long document into smaller chunks that can fit into your model's context window. LangChain has a number of built-in document transformers that make it easy to split, combine, filter, and otherwise manipulate documents. When you want to deal with long pieces of text, it is necessary to split up that text into chunks. As simple as this sounds, there is a lot of potential complexity here. Ideally, you want to keep the semantically related pieces of text together. What "semantically related" means could depend on the type of text. This notebook showcases several ways to do that. At a high level, text splitters work as following: Split the text up into small, semantically meaningful chunks (often sentences). Start combining these small chunks into a larger chunk until you reach a certain size (as measured by some function). Once you reach that size, make that chunk its own piece of text and then start creating a new chunk of text with some overlap (to keep context between chunks). That means there are two different axes along which you can customize your text splitter: How the text is split How the chunk size is measured Types of Text Splitters​ LangChain offers many different types of text splitters. These all live in the langchain-text-splitters package. Below is a table listing all of them, along with a few characteristics: Name: Name of the text splitter Splits On: How this text splitter splits text Adds Metadata: Whether or not this text splitter adds metadata about where each chunk came from. Description: Description of the splitter, including recommendation on when to use it. NameSplits OnAdds MetadataDescription Recursive A list of user defined characters Recursively splits text. Splitting text recursively serves the purpose of trying to keep related pieces of text next to each other. This is the recommended way to start splitting text. HTML HTML specific characters ✅ Splits text based on HTML-specific characters. Notably, this adds in relevant information about where that chunk came from (based on the HTML) Markdown Markdown specific characters ✅ Splits text based on Markdown-specific characters. Notably, this adds in relevant information about where that chunk came from (based on the Markdown) Code Code (Python, JS) specific characters Splits text based on characters specific to coding languages. 15 different languages are available to choose from. Token Tokens Splits text on tokens. There exist a few different ways to measure tokens. Character A user defined character Splits text based on a user defined character. One of the simpler methods. [Experimental] Semantic Chunker Sentences First splits on sentences. Then combines ones next to each other if they are semantically similar enough. Taken from Greg Kamradt AI21 Semantic Text Splitter Semantics ✅ Identifies distinct topics that form coherent pieces of text and splits along those. Evaluate text splitters​ You can evaluate text splitters with the Chunkviz utility created by Greg Kamradt. Chunkviz is a great tool for visualizing how your text splitter is working. It will show you how your text is being split up and help in tuning up the splitting parameters. Other Document Transforms​ Text splitting is only one example of transformations that you may want to do on documents before passing them to an LLM. Head to Integrations for documentation on built-in document transformer integrations with 3rd-party tools.

https://python.langchain.com/docs/modules/agents/how_to/handle_parsing_errors/

## Handle parsing errors Occasionally the LLM cannot determine what step to take because its outputs are not correctly formatted to be handled by the output parser. In this case, by default the agent errors. But you can easily control this functionality with `handle_parsing_errors`! Let’s explore how. ## Setup[​](#setup "Direct link to Setup") We will be using a wikipedia tool, so need to install that ``` %pip install --upgrade --quiet wikipedia ``` ``` from langchain import hubfrom langchain.agents import AgentExecutor, create_react_agentfrom langchain_community.tools import WikipediaQueryRunfrom langchain_community.utilities import WikipediaAPIWrapperfrom langchain_openai import OpenAIapi_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=100)tool = WikipediaQueryRun(api_wrapper=api_wrapper)tools = [tool]# Get the prompt to use - you can modify this!# You can see the full prompt used at: https://smith.langchain.com/hub/hwchase17/reactprompt = hub.pull("hwchase17/react")llm = OpenAI(temperature=0)agent = create_react_agent(llm, tools, prompt) ``` ## Error[​](#error "Direct link to Error") In this scenario, the agent will error because it fails to output an Action string (which we’ve tricked it into doing with a malicious input ``` agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) ``` ``` agent_executor.invoke( {"input": "What is Leo DiCaprio's middle name?\n\nAction: Wikipedia"}) ``` ``` > Entering new AgentExecutor chain... ``` ``` ValueError: An output parsing error occurred. In order to pass this error back to the agent and have it try again, pass `handle_parsing_errors=True` to the AgentExecutor. This is the error: Could not parse LLM output: ` I should search for "Leo DiCaprio" on WikipediaAction Input: Leo DiCaprio` ``` ## Default error handling[​](#default-error-handling "Direct link to Default error handling") Handle errors with `Invalid or incomplete response`: ``` agent_executor = AgentExecutor( agent=agent, tools=tools, verbose=True, handle_parsing_errors=True) ``` ``` agent_executor.invoke( {"input": "What is Leo DiCaprio's middle name?\n\nAction: Wikipedia"}) ``` ``` > Entering new AgentExecutor chain... I should search for "Leo DiCaprio" on WikipediaAction Input: Leo DiCaprioInvalid Format: Missing 'Action:' after 'Thought:I should search for "Leonardo DiCaprio" on WikipediaAction: WikipediaAction Input: Leonardo DiCaprioPage: Leonardo DiCaprioSummary: Leonardo Wilhelm DiCaprio (; Italian: [diˈkaːprjo]; born November 1I now know the final answerFinal Answer: Leonardo Wilhelm> Finished chain. ``` ``` {'input': "What is Leo DiCaprio's middle name?\n\nAction: Wikipedia", 'output': 'Leonardo Wilhelm'} ``` ## Custom error message[​](#custom-error-message "Direct link to Custom error message") You can easily customize the message to use when there are parsing errors. ``` agent_executor = AgentExecutor( agent=agent, tools=tools, verbose=True, handle_parsing_errors="Check your output and make sure it conforms, use the Action/Action Input syntax",) ``` ``` agent_executor.invoke( {"input": "What is Leo DiCaprio's middle name?\n\nAction: Wikipedia"}) ``` ``` > Entering new AgentExecutor chain...Could not parse LLM output: ` I should search for "Leo DiCaprio" on WikipediaAction Input: Leo DiCaprio`Check your output and make sure it conforms, use the Action/Action Input syntaxI should look for a section on Leo DiCaprio's personal lifeAction: WikipediaAction Input: Leo DiCaprioPage: Leonardo DiCaprioSummary: Leonardo Wilhelm DiCaprio (; Italian: [diˈkaːprjo]; born November 1I should look for a section on Leo DiCaprio's personal lifeAction: WikipediaAction Input: Leonardo DiCaprioPage: Leonardo DiCaprioSummary: Leonardo Wilhelm DiCaprio (; Italian: [diˈkaːprjo]; born November 1I should look for a section on Leo DiCaprio's personal lifeAction: WikipediaAction Input: Leonardo Wilhelm DiCaprioPage: Leonardo DiCaprioSummary: Leonardo Wilhelm DiCaprio (; Italian: [diˈkaːprjo]; born November 1I should look for a section on Leo DiCaprio's personal lifeAction: WikipediaAction Input: Leonardo Wilhelm DiCaprioPage: Leonardo DiCaprioSummary: Leonardo Wilhelm DiCaprio (; Italian: [diˈkaːprjo]; born November 1I now know the final answerFinal Answer: Leonardo Wilhelm DiCaprio> Finished chain. ``` ``` {'input': "What is Leo DiCaprio's middle name?\n\nAction: Wikipedia", 'output': 'Leonardo Wilhelm DiCaprio'} ``` ## Custom Error Function[​](#custom-error-function "Direct link to Custom Error Function") You can also customize the error to be a function that takes the error in and outputs a string. ``` def _handle_error(error) -> str: return str(error)[:50]agent_executor = AgentExecutor( agent=agent, tools=tools, verbose=True, handle_parsing_errors=_handle_error,) ``` ``` agent_executor.invoke( {"input": "What is Leo DiCaprio's middle name?\n\nAction: Wikipedia"}) ``` ``` > Entering new AgentExecutor chain...Could not parse LLM output: ` I should search for "Leo DiCaprio" on WikipediaAction Input: Leo DiCaprio`Could not parse LLM output: ` I should search for I should look for a section on his personal lifeAction: WikipediaAction Input: Personal lifePage: Personal lifeSummary: Personal life is the course or state of an individual's life, especiallI should look for a section on his early lifeAction: WikipediaAction Input: Early lifeNo good Wikipedia Search Result was foundI should try searching for "Leonardo DiCaprio" insteadAction: WikipediaAction Input: Leonardo DiCaprioPage: Leonardo DiCaprioSummary: Leonardo Wilhelm DiCaprio (; Italian: [diˈkaːprjo]; born November 1I should look for a section on his personal life againAction: WikipediaAction Input: Personal lifePage: Personal lifeSummary: Personal life is the course or state of an individual's life, especiallI now know the final answerFinal Answer: Leonardo Wilhelm DiCaprio> Finished chain. ``` ``` /Users/harrisonchase/.pyenv/versions/3.10.1/envs/langchain/lib/python3.10/site-packages/wikipedia/wikipedia.py:389: GuessedAtParserWarning: No parser was explicitly specified, so I'm using the best available HTML parser for this system ("lxml"). This usually isn't a problem, but if you run this code on another system, or in a different virtual environment, it may use a different parser and behave differently.The code that caused this warning is on line 389 of the file /Users/harrisonchase/.pyenv/versions/3.10.1/envs/langchain/lib/python3.10/site-packages/wikipedia/wikipedia.py. To get rid of this warning, pass the additional argument 'features="lxml"' to the BeautifulSoup constructor. lis = BeautifulSoup(html).find_all('li') ``` ``` {'input': "What is Leo DiCaprio's middle name?\n\nAction: Wikipedia", 'output': 'Leonardo Wilhelm DiCaprio'} ```

Handle parsing errors Occasionally the LLM cannot determine what step to take because its outputs are not correctly formatted to be handled by the output parser. In this case, by default the agent errors. But you can easily control this functionality with handle_parsing_errors! Let’s explore how. Setup​ We will be using a wikipedia tool, so need to install that %pip install --upgrade --quiet wikipedia from langchain import hub from langchain.agents import AgentExecutor, create_react_agent from langchain_community.tools import WikipediaQueryRun from langchain_community.utilities import WikipediaAPIWrapper from langchain_openai import OpenAI api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=100) tool = WikipediaQueryRun(api_wrapper=api_wrapper) tools = [tool] # Get the prompt to use - you can modify this! # You can see the full prompt used at: https://smith.langchain.com/hub/hwchase17/react prompt = hub.pull("hwchase17/react") llm = OpenAI(temperature=0) agent = create_react_agent(llm, tools, prompt) Error​ In this scenario, the agent will error because it fails to output an Action string (which we’ve tricked it into doing with a malicious input agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) agent_executor.invoke( {"input": "What is Leo DiCaprio's middle name?\n\nAction: Wikipedia"} ) > Entering new AgentExecutor chain... ValueError: An output parsing error occurred. In order to pass this error back to the agent and have it try again, pass `handle_parsing_errors=True` to the AgentExecutor. This is the error: Could not parse LLM output: ` I should search for "Leo DiCaprio" on Wikipedia Action Input: Leo DiCaprio` Default error handling​ Handle errors with Invalid or incomplete response: agent_executor = AgentExecutor( agent=agent, tools=tools, verbose=True, handle_parsing_errors=True ) agent_executor.invoke( {"input": "What is Leo DiCaprio's middle name?\n\nAction: Wikipedia"} ) > Entering new AgentExecutor chain... I should search for "Leo DiCaprio" on Wikipedia Action Input: Leo DiCaprioInvalid Format: Missing 'Action:' after 'Thought:I should search for "Leonardo DiCaprio" on Wikipedia Action: Wikipedia Action Input: Leonardo DiCaprioPage: Leonardo DiCaprio Summary: Leonardo Wilhelm DiCaprio (; Italian: [diˈkaːprjo]; born November 1I now know the final answer Final Answer: Leonardo Wilhelm > Finished chain. {'input': "What is Leo DiCaprio's middle name?\n\nAction: Wikipedia", 'output': 'Leonardo Wilhelm'} Custom error message​ You can easily customize the message to use when there are parsing errors. agent_executor = AgentExecutor( agent=agent, tools=tools, verbose=True, handle_parsing_errors="Check your output and make sure it conforms, use the Action/Action Input syntax", ) agent_executor.invoke( {"input": "What is Leo DiCaprio's middle name?\n\nAction: Wikipedia"} ) > Entering new AgentExecutor chain... Could not parse LLM output: ` I should search for "Leo DiCaprio" on Wikipedia Action Input: Leo DiCaprio`Check your output and make sure it conforms, use the Action/Action Input syntaxI should look for a section on Leo DiCaprio's personal life Action: Wikipedia Action Input: Leo DiCaprioPage: Leonardo DiCaprio Summary: Leonardo Wilhelm DiCaprio (; Italian: [diˈkaːprjo]; born November 1I should look for a section on Leo DiCaprio's personal life Action: Wikipedia Action Input: Leonardo DiCaprioPage: Leonardo DiCaprio Summary: Leonardo Wilhelm DiCaprio (; Italian: [diˈkaːprjo]; born November 1I should look for a section on Leo DiCaprio's personal life Action: Wikipedia Action Input: Leonardo Wilhelm DiCaprioPage: Leonardo DiCaprio Summary: Leonardo Wilhelm DiCaprio (; Italian: [diˈkaːprjo]; born November 1I should look for a section on Leo DiCaprio's personal life Action: Wikipedia Action Input: Leonardo Wilhelm DiCaprioPage: Leonardo DiCaprio Summary: Leonardo Wilhelm DiCaprio (; Italian: [diˈkaːprjo]; born November 1I now know the final answer Final Answer: Leonardo Wilhelm DiCaprio > Finished chain. {'input': "What is Leo DiCaprio's middle name?\n\nAction: Wikipedia", 'output': 'Leonardo Wilhelm DiCaprio'} Custom Error Function​ You can also customize the error to be a function that takes the error in and outputs a string. def _handle_error(error) -> str: return str(error)[:50] agent_executor = AgentExecutor( agent=agent, tools=tools, verbose=True, handle_parsing_errors=_handle_error, ) agent_executor.invoke( {"input": "What is Leo DiCaprio's middle name?\n\nAction: Wikipedia"} ) > Entering new AgentExecutor chain... Could not parse LLM output: ` I should search for "Leo DiCaprio" on Wikipedia Action Input: Leo DiCaprio`Could not parse LLM output: ` I should search for I should look for a section on his personal life Action: Wikipedia Action Input: Personal lifePage: Personal life Summary: Personal life is the course or state of an individual's life, especiallI should look for a section on his early life Action: Wikipedia Action Input: Early lifeNo good Wikipedia Search Result was foundI should try searching for "Leonardo DiCaprio" instead Action: Wikipedia Action Input: Leonardo DiCaprioPage: Leonardo DiCaprio Summary: Leonardo Wilhelm DiCaprio (; Italian: [diˈkaːprjo]; born November 1I should look for a section on his personal life again Action: Wikipedia Action Input: Personal lifePage: Personal life Summary: Personal life is the course or state of an individual's life, especiallI now know the final answer Final Answer: Leonardo Wilhelm DiCaprio > Finished chain. /Users/harrisonchase/.pyenv/versions/3.10.1/envs/langchain/lib/python3.10/site-packages/wikipedia/wikipedia.py:389: GuessedAtParserWarning: No parser was explicitly specified, so I'm using the best available HTML parser for this system ("lxml"). This usually isn't a problem, but if you run this code on another system, or in a different virtual environment, it may use a different parser and behave differently. The code that caused this warning is on line 389 of the file /Users/harrisonchase/.pyenv/versions/3.10.1/envs/langchain/lib/python3.10/site-packages/wikipedia/wikipedia.py. To get rid of this warning, pass the additional argument 'features="lxml"' to the BeautifulSoup constructor. lis = BeautifulSoup(html).find_all('li') {'input': "What is Leo DiCaprio's middle name?\n\nAction: Wikipedia", 'output': 'Leonardo Wilhelm DiCaprio'}

https://python.langchain.com/docs/modules/data_connection/document_transformers/character_text_splitter/

## Split by character This is the simplest method. This splits based on characters (by default “”) and measure chunk length by number of characters. 1. How the text is split: by single character. 2. How the chunk size is measured: by number of characters. ``` %pip install -qU langchain-text-splitters ``` ``` # This is a long document we can split up.with open("../../state_of_the_union.txt") as f: state_of_the_union = f.read() ``` ``` from langchain_text_splitters import CharacterTextSplittertext_splitter = CharacterTextSplitter( separator="\n\n", chunk_size=1000, chunk_overlap=200, length_function=len, is_separator_regex=False,) ``` ``` texts = text_splitter.create_documents([state_of_the_union])print(texts[0]) ``` ``` page_content='Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. \n\nLast year COVID-19 kept us apart. This year we are finally together again. \n\nTonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. \n\nWith a duty to one another to the American people to the Constitution. \n\nAnd with an unwavering resolve that freedom will always triumph over tyranny. \n\nSix days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. \n\nHe thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. \n\nHe met the Ukrainian people. \n\nFrom President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world.' ``` Here’s an example of passing metadata along with the documents, notice that it is split along with the documents. ``` metadatas = [{"document": 1}, {"document": 2}]documents = text_splitter.create_documents( [state_of_the_union, state_of_the_union], metadatas=metadatas)print(documents[0]) ``` ``` page_content='Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. \n\nLast year COVID-19 kept us apart. This year we are finally together again. \n\nTonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. \n\nWith a duty to one another to the American people to the Constitution. \n\nAnd with an unwavering resolve that freedom will always triumph over tyranny. \n\nSix days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. \n\nHe thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. \n\nHe met the Ukrainian people. \n\nFrom President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world.' metadata={'document': 1} ``` ``` text_splitter.split_text(state_of_the_union)[0] ``` ``` 'Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. \n\nLast year COVID-19 kept us apart. This year we are finally together again. \n\nTonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. \n\nWith a duty to one another to the American people to the Constitution. \n\nAnd with an unwavering resolve that freedom will always triumph over tyranny. \n\nSix days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. \n\nHe thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. \n\nHe met the Ukrainian people. \n\nFrom President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world.' ``` * * * #### Help us out by providing feedback on this documentation page:

Split by character This is the simplest method. This splits based on characters (by default “”) and measure chunk length by number of characters. How the text is split: by single character. How the chunk size is measured: by number of characters. %pip install -qU langchain-text-splitters # This is a long document we can split up. with open("../../state_of_the_union.txt") as f: state_of_the_union = f.read() from langchain_text_splitters import CharacterTextSplitter text_splitter = CharacterTextSplitter( separator="\n\n", chunk_size=1000, chunk_overlap=200, length_function=len, is_separator_regex=False, ) texts = text_splitter.create_documents([state_of_the_union]) print(texts[0]) page_content='Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. \n\nLast year COVID-19 kept us apart. This year we are finally together again. \n\nTonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. \n\nWith a duty to one another to the American people to the Constitution. \n\nAnd with an unwavering resolve that freedom will always triumph over tyranny. \n\nSix days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. \n\nHe thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. \n\nHe met the Ukrainian people. \n\nFrom President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world.' Here’s an example of passing metadata along with the documents, notice that it is split along with the documents. metadatas = [{"document": 1}, {"document": 2}] documents = text_splitter.create_documents( [state_of_the_union, state_of_the_union], metadatas=metadatas ) print(documents[0]) page_content='Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. \n\nLast year COVID-19 kept us apart. This year we are finally together again. \n\nTonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. \n\nWith a duty to one another to the American people to the Constitution. \n\nAnd with an unwavering resolve that freedom will always triumph over tyranny. \n\nSix days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. \n\nHe thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. \n\nHe met the Ukrainian people. \n\nFrom President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world.' metadata={'document': 1} text_splitter.split_text(state_of_the_union)[0] 'Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. \n\nLast year COVID-19 kept us apart. This year we are finally together again. \n\nTonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. \n\nWith a duty to one another to the American people to the Constitution. \n\nAnd with an unwavering resolve that freedom will always triumph over tyranny. \n\nSix days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. \n\nHe thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. \n\nHe met the Ukrainian people. \n\nFrom President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world.' Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/modules/data_connection/document_transformers/code_splitter/

## Split code CodeTextSplitter allows you to split your code with multiple languages supported. Import enum `Language` and specify the language. ``` %pip install -qU langchain-text-splitters ``` ``` from langchain_text_splitters import ( Language, RecursiveCharacterTextSplitter,) ``` ``` # Full list of supported languages[e.value for e in Language] ``` ``` ['cpp', 'go', 'java', 'kotlin', 'js', 'ts', 'php', 'proto', 'python', 'rst', 'ruby', 'rust', 'scala', 'swift', 'markdown', 'latex', 'html', 'sol', 'csharp', 'cobol', 'c', 'lua', 'perl', 'haskell'] ``` ``` # You can also see the separators used for a given languageRecursiveCharacterTextSplitter.get_separators_for_language(Language.PYTHON) ``` ``` ['\nclass ', '\ndef ', '\n\tdef ', '\n\n', '\n', ' ', ''] ``` ## Python[​](#python "Direct link to Python") Here’s an example using the PythonTextSplitter: ``` PYTHON_CODE = """def hello_world(): print("Hello, World!")# Call the functionhello_world()"""python_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.PYTHON, chunk_size=50, chunk_overlap=0)python_docs = python_splitter.create_documents([PYTHON_CODE])python_docs ``` ``` [Document(page_content='def hello_world():\n print("Hello, World!")'), Document(page_content='# Call the function\nhello_world()')] ``` ## JS[​](#js "Direct link to JS") Here’s an example using the JS text splitter: ``` JS_CODE = """function helloWorld() { console.log("Hello, World!");}// Call the functionhelloWorld();"""js_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.JS, chunk_size=60, chunk_overlap=0)js_docs = js_splitter.create_documents([JS_CODE])js_docs ``` ``` [Document(page_content='function helloWorld() {\n console.log("Hello, World!");\n}'), Document(page_content='// Call the function\nhelloWorld();')] ``` ## TS[​](#ts "Direct link to TS") Here’s an example using the TS text splitter: ``` TS_CODE = """function helloWorld(): void { console.log("Hello, World!");}// Call the functionhelloWorld();"""ts_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.TS, chunk_size=60, chunk_overlap=0)ts_docs = ts_splitter.create_documents([TS_CODE])ts_docs ``` ``` [Document(page_content='function helloWorld(): void {'), Document(page_content='console.log("Hello, World!");\n}'), Document(page_content='// Call the function\nhelloWorld();')] ``` ## Markdown[​](#markdown "Direct link to Markdown") Here’s an example using the Markdown text splitter: ``` markdown_text = """# 🦜️🔗 LangChain⚡ Building applications with LLMs through composability ⚡## Quick Install```bash# Hopefully this code block isn't splitpip install langchain```As an open-source project in a rapidly developing field, we are extremely open to contributions.""" ``` ``` md_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.MARKDOWN, chunk_size=60, chunk_overlap=0)md_docs = md_splitter.create_documents([markdown_text])md_docs ``` ``` [Document(page_content='# 🦜️🔗 LangChain'), Document(page_content='⚡ Building applications with LLMs through composability ⚡'), Document(page_content='## Quick Install\n\n```bash'), Document(page_content="# Hopefully this code block isn't split"), Document(page_content='pip install langchain'), Document(page_content='```'), Document(page_content='As an open-source project in a rapidly developing field, we'), Document(page_content='are extremely open to contributions.')] ``` ## Latex[​](#latex "Direct link to Latex") Here’s an example on Latex text: ``` latex_text = """\documentclass{article}\begin{document}\maketitle\section{Introduction}Large language models (LLMs) are a type of machine learning model that can be trained on vast amounts of text data to generate human-like language. In recent years, LLMs have made significant advances in a variety of natural language processing tasks, including language translation, text generation, and sentiment analysis.\subsection{History of LLMs}The earliest LLMs were developed in the 1980s and 1990s, but they were limited by the amount of data that could be processed and the computational power available at the time. In the past decade, however, advances in hardware and software have made it possible to train LLMs on massive datasets, leading to significant improvements in performance.\subsection{Applications of LLMs}LLMs have many applications in industry, including chatbots, content creation, and virtual assistants. They can also be used in academia for research in linguistics, psychology, and computational linguistics.\end{document}""" ``` ``` latex_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.MARKDOWN, chunk_size=60, chunk_overlap=0)latex_docs = latex_splitter.create_documents([latex_text])latex_docs ``` ``` [Document(page_content='\\documentclass{article}\n\n\x08egin{document}\n\n\\maketitle'), Document(page_content='\\section{Introduction}'), Document(page_content='Large language models (LLMs) are a type of machine learning'), Document(page_content='model that can be trained on vast amounts of text data to'), Document(page_content='generate human-like language. In recent years, LLMs have'), Document(page_content='made significant advances in a variety of natural language'), Document(page_content='processing tasks, including language translation, text'), Document(page_content='generation, and sentiment analysis.'), Document(page_content='\\subsection{History of LLMs}'), Document(page_content='The earliest LLMs were developed in the 1980s and 1990s,'), Document(page_content='but they were limited by the amount of data that could be'), Document(page_content='processed and the computational power available at the'), Document(page_content='time. In the past decade, however, advances in hardware and'), Document(page_content='software have made it possible to train LLMs on massive'), Document(page_content='datasets, leading to significant improvements in'), Document(page_content='performance.'), Document(page_content='\\subsection{Applications of LLMs}'), Document(page_content='LLMs have many applications in industry, including'), Document(page_content='chatbots, content creation, and virtual assistants. They'), Document(page_content='can also be used in academia for research in linguistics,'), Document(page_content='psychology, and computational linguistics.'), Document(page_content='\\end{document}')] ``` ## HTML[​](#html "Direct link to HTML") Here’s an example using an HTML text splitter: ``` html_text = """<!DOCTYPE html><html> <head> <title>🦜️🔗 LangChain</title> <style> body { font-family: Arial, sans-serif; } h1 { color: darkblue; } </style> </head> <body> <div> <h1>🦜️🔗 LangChain</h1> <p>⚡ Building applications with LLMs through composability ⚡</p> </div> <div> As an open-source project in a rapidly developing field, we are extremely open to contributions. </div> </body></html>""" ``` ``` html_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.HTML, chunk_size=60, chunk_overlap=0)html_docs = html_splitter.create_documents([html_text])html_docs ``` ``` [Document(page_content='<!DOCTYPE html>\n<html>'), Document(page_content='<head>\n <title>🦜️🔗 LangChain</title>'), Document(page_content='<style>\n body {\n font-family: Aria'), Document(page_content='l, sans-serif;\n }\n h1 {'), Document(page_content='color: darkblue;\n }\n </style>\n </head'), Document(page_content='>'), Document(page_content='<body>'), Document(page_content='<div>\n <h1>🦜️🔗 LangChain</h1>'), Document(page_content='<p>⚡ Building applications with LLMs through composability ⚡'), Document(page_content='</p>\n </div>'), Document(page_content='<div>\n As an open-source project in a rapidly dev'), Document(page_content='eloping field, we are extremely open to contributions.'), Document(page_content='</div>\n </body>\n</html>')] ``` ## Solidity[​](#solidity "Direct link to Solidity") Here’s an example using the Solidity text splitter: ``` SOL_CODE = """pragma solidity ^0.8.20;contract HelloWorld { function add(uint a, uint b) pure public returns(uint) { return a + b; }}"""sol_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.SOL, chunk_size=128, chunk_overlap=0)sol_docs = sol_splitter.create_documents([SOL_CODE])sol_docs ``` ``` [Document(page_content='pragma solidity ^0.8.20;'), Document(page_content='contract HelloWorld {\n function add(uint a, uint b) pure public returns(uint) {\n return a + b;\n }\n}')] ``` ## C[​](#c "Direct link to C") Here’s an example using the C# text splitter: ``` C_CODE = """using System;class Program{ static void Main() { int age = 30; // Change the age value as needed // Categorize the age without any console output if (age < 18) { // Age is under 18 } else if (age >= 18 && age < 65) { // Age is an adult } else { // Age is a senior citizen } }}"""c_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.CSHARP, chunk_size=128, chunk_overlap=0)c_docs = c_splitter.create_documents([C_CODE])c_docs ``` ``` [Document(page_content='using System;'), Document(page_content='class Program\n{\n static void Main()\n {\n int age = 30; // Change the age value as needed'), Document(page_content='// Categorize the age without any console output\n if (age < 18)\n {\n // Age is under 18'), Document(page_content='}\n else if (age >= 18 && age < 65)\n {\n // Age is an adult\n }\n else\n {'), Document(page_content='// Age is a senior citizen\n }\n }\n}')] ``` ## Haskell[​](#haskell "Direct link to Haskell") Here’s an example using the Haskell text splitter: ``` HASKELL_CODE = """main :: IO ()main = do putStrLn "Hello, World!"-- Some sample functionsadd :: Int -> Int -> Intadd x y = x + y"""haskell_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.HASKELL, chunk_size=50, chunk_overlap=0)haskell_docs = haskell_splitter.create_documents([HASKELL_CODE])haskell_docs ``` ``` [Document(page_content='main :: IO ()'), Document(page_content='main = do\n putStrLn "Hello, World!"\n-- Some'), Document(page_content='sample functions\nadd :: Int -> Int -> Int\nadd x y'), Document(page_content='= x + y')] ``` ## PHP[​](#php "Direct link to PHP") Here’s an example using the PHP text splitter: ``` PHP_CODE = """<?phpnamespace foo;class Hello { public function __construct() { }}function hello() { echo "Hello World!";}interface Human { public function breath();}trait Foo { }enum Color{ case Red; case Blue;}"""php_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.PHP, chunk_size=50, chunk_overlap=0)haskell_docs = php_splitter.create_documents([PHP_CODE])haskell_docs ``` ``` [Document(page_content='<?php\nnamespace foo;'), Document(page_content='class Hello {'), Document(page_content='public function __construct() { }\n}'), Document(page_content='function hello() {\n echo "Hello World!";\n}'), Document(page_content='interface Human {\n public function breath();\n}'), Document(page_content='trait Foo { }\nenum Color\n{\n case Red;'), Document(page_content='case Blue;\n}')] ```

Split code CodeTextSplitter allows you to split your code with multiple languages supported. Import enum Language and specify the language. %pip install -qU langchain-text-splitters from langchain_text_splitters import ( Language, RecursiveCharacterTextSplitter, ) # Full list of supported languages [e.value for e in Language] ['cpp', 'go', 'java', 'kotlin', 'js', 'ts', 'php', 'proto', 'python', 'rst', 'ruby', 'rust', 'scala', 'swift', 'markdown', 'latex', 'html', 'sol', 'csharp', 'cobol', 'c', 'lua', 'perl', 'haskell'] # You can also see the separators used for a given language RecursiveCharacterTextSplitter.get_separators_for_language(Language.PYTHON) ['\nclass ', '\ndef ', '\n\tdef ', '\n\n', '\n', ' ', ''] Python​ Here’s an example using the PythonTextSplitter: PYTHON_CODE = """ def hello_world(): print("Hello, World!") # Call the function hello_world() """ python_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.PYTHON, chunk_size=50, chunk_overlap=0 ) python_docs = python_splitter.create_documents([PYTHON_CODE]) python_docs [Document(page_content='def hello_world():\n print("Hello, World!")'), Document(page_content='# Call the function\nhello_world()')] JS​ Here’s an example using the JS text splitter: JS_CODE = """ function helloWorld() { console.log("Hello, World!"); } // Call the function helloWorld(); """ js_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.JS, chunk_size=60, chunk_overlap=0 ) js_docs = js_splitter.create_documents([JS_CODE]) js_docs [Document(page_content='function helloWorld() {\n console.log("Hello, World!");\n}'), Document(page_content='// Call the function\nhelloWorld();')] TS​ Here’s an example using the TS text splitter: TS_CODE = """ function helloWorld(): void { console.log("Hello, World!"); } // Call the function helloWorld(); """ ts_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.TS, chunk_size=60, chunk_overlap=0 ) ts_docs = ts_splitter.create_documents([TS_CODE]) ts_docs [Document(page_content='function helloWorld(): void {'), Document(page_content='console.log("Hello, World!");\n}'), Document(page_content='// Call the function\nhelloWorld();')] Markdown​ Here’s an example using the Markdown text splitter: markdown_text = """ # 🦜️🔗 LangChain ⚡ Building applications with LLMs through composability ⚡ ## Quick Install ```bash # Hopefully this code block isn't split pip install langchain ``` As an open-source project in a rapidly developing field, we are extremely open to contributions. """ md_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.MARKDOWN, chunk_size=60, chunk_overlap=0 ) md_docs = md_splitter.create_documents([markdown_text]) md_docs [Document(page_content='# 🦜️🔗 LangChain'), Document(page_content='⚡ Building applications with LLMs through composability ⚡'), Document(page_content='## Quick Install\n\n```bash'), Document(page_content="# Hopefully this code block isn't split"), Document(page_content='pip install langchain'), Document(page_content='```'), Document(page_content='As an open-source project in a rapidly developing field, we'), Document(page_content='are extremely open to contributions.')] Latex​ Here’s an example on Latex text: latex_text = """ \documentclass{article} \begin{document} \maketitle \section{Introduction} Large language models (LLMs) are a type of machine learning model that can be trained on vast amounts of text data to generate human-like language. In recent years, LLMs have made significant advances in a variety of natural language processing tasks, including language translation, text generation, and sentiment analysis. \subsection{History of LLMs} The earliest LLMs were developed in the 1980s and 1990s, but they were limited by the amount of data that could be processed and the computational power available at the time. In the past decade, however, advances in hardware and software have made it possible to train LLMs on massive datasets, leading to significant improvements in performance. \subsection{Applications of LLMs} LLMs have many applications in industry, including chatbots, content creation, and virtual assistants. They can also be used in academia for research in linguistics, psychology, and computational linguistics. \end{document} """ latex_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.MARKDOWN, chunk_size=60, chunk_overlap=0 ) latex_docs = latex_splitter.create_documents([latex_text]) latex_docs [Document(page_content='\\documentclass{article}\n\n\x08egin{document}\n\n\\maketitle'), Document(page_content='\\section{Introduction}'), Document(page_content='Large language models (LLMs) are a type of machine learning'), Document(page_content='model that can be trained on vast amounts of text data to'), Document(page_content='generate human-like language. In recent years, LLMs have'), Document(page_content='made significant advances in a variety of natural language'), Document(page_content='processing tasks, including language translation, text'), Document(page_content='generation, and sentiment analysis.'), Document(page_content='\\subsection{History of LLMs}'), Document(page_content='The earliest LLMs were developed in the 1980s and 1990s,'), Document(page_content='but they were limited by the amount of data that could be'), Document(page_content='processed and the computational power available at the'), Document(page_content='time. In the past decade, however, advances in hardware and'), Document(page_content='software have made it possible to train LLMs on massive'), Document(page_content='datasets, leading to significant improvements in'), Document(page_content='performance.'), Document(page_content='\\subsection{Applications of LLMs}'), Document(page_content='LLMs have many applications in industry, including'), Document(page_content='chatbots, content creation, and virtual assistants. They'), Document(page_content='can also be used in academia for research in linguistics,'), Document(page_content='psychology, and computational linguistics.'), Document(page_content='\\end{document}')] HTML​ Here’s an example using an HTML text splitter: html_text = """ <!DOCTYPE html> <html> <head> <title>🦜️🔗 LangChain</title> <style> body { font-family: Arial, sans-serif; } h1 { color: darkblue; } </style> </head> <body> <div> <h1>🦜️🔗 LangChain</h1> <p>⚡ Building applications with LLMs through composability ⚡</p> </div> <div> As an open-source project in a rapidly developing field, we are extremely open to contributions. </div> </body> </html> """ html_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.HTML, chunk_size=60, chunk_overlap=0 ) html_docs = html_splitter.create_documents([html_text]) html_docs [Document(page_content='<!DOCTYPE html>\n<html>'), Document(page_content='<head>\n <title>🦜️🔗 LangChain</title>'), Document(page_content='<style>\n body {\n font-family: Aria'), Document(page_content='l, sans-serif;\n }\n h1 {'), Document(page_content='color: darkblue;\n }\n </style>\n </head'), Document(page_content='>'), Document(page_content='<body>'), Document(page_content='<div>\n <h1>🦜️🔗 LangChain</h1>'), Document(page_content='<p>⚡ Building applications with LLMs through composability ⚡'), Document(page_content='</p>\n </div>'), Document(page_content='<div>\n As an open-source project in a rapidly dev'), Document(page_content='eloping field, we are extremely open to contributions.'), Document(page_content='</div>\n </body>\n</html>')] Solidity​ Here’s an example using the Solidity text splitter: SOL_CODE = """ pragma solidity ^0.8.20; contract HelloWorld { function add(uint a, uint b) pure public returns(uint) { return a + b; } } """ sol_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.SOL, chunk_size=128, chunk_overlap=0 ) sol_docs = sol_splitter.create_documents([SOL_CODE]) sol_docs [Document(page_content='pragma solidity ^0.8.20;'), Document(page_content='contract HelloWorld {\n function add(uint a, uint b) pure public returns(uint) {\n return a + b;\n }\n}')] C​ Here’s an example using the C# text splitter: C_CODE = """ using System; class Program { static void Main() { int age = 30; // Change the age value as needed // Categorize the age without any console output if (age < 18) { // Age is under 18 } else if (age >= 18 && age < 65) { // Age is an adult } else { // Age is a senior citizen } } } """ c_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.CSHARP, chunk_size=128, chunk_overlap=0 ) c_docs = c_splitter.create_documents([C_CODE]) c_docs [Document(page_content='using System;'), Document(page_content='class Program\n{\n static void Main()\n {\n int age = 30; // Change the age value as needed'), Document(page_content='// Categorize the age without any console output\n if (age < 18)\n {\n // Age is under 18'), Document(page_content='}\n else if (age >= 18 && age < 65)\n {\n // Age is an adult\n }\n else\n {'), Document(page_content='// Age is a senior citizen\n }\n }\n}')] Haskell​ Here’s an example using the Haskell text splitter: HASKELL_CODE = """ main :: IO () main = do putStrLn "Hello, World!" -- Some sample functions add :: Int -> Int -> Int add x y = x + y """ haskell_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.HASKELL, chunk_size=50, chunk_overlap=0 ) haskell_docs = haskell_splitter.create_documents([HASKELL_CODE]) haskell_docs [Document(page_content='main :: IO ()'), Document(page_content='main = do\n putStrLn "Hello, World!"\n-- Some'), Document(page_content='sample functions\nadd :: Int -> Int -> Int\nadd x y'), Document(page_content='= x + y')] PHP​ Here’s an example using the PHP text splitter: PHP_CODE = """<?php namespace foo; class Hello { public function __construct() { } } function hello() { echo "Hello World!"; } interface Human { public function breath(); } trait Foo { } enum Color { case Red; case Blue; }""" php_splitter = RecursiveCharacterTextSplitter.from_language( language=Language.PHP, chunk_size=50, chunk_overlap=0 ) haskell_docs = php_splitter.create_documents([PHP_CODE]) haskell_docs [Document(page_content='<?php\nnamespace foo;'), Document(page_content='class Hello {'), Document(page_content='public function __construct() { }\n}'), Document(page_content='function hello() {\n echo "Hello World!";\n}'), Document(page_content='interface Human {\n public function breath();\n}'), Document(page_content='trait Foo { }\nenum Color\n{\n case Red;'), Document(page_content='case Blue;\n}')]

https://python.langchain.com/docs/modules/data_connection/document_transformers/HTML_header_metadata/

## Split by HTML header ## Description and motivation[​](#description-and-motivation "Direct link to Description and motivation") Similar in concept to the [\`MarkdownHeaderTextSplitter\`](https://python.langchain.com/docs/modules/data_connection/document_transformers/text_splitters/markdown_header_metadata), the \`HTMLHeaderTextSplitter\` is a “structure-aware” chunker that splits text at the element level and adds metadata for each header “relevant” to any given chunk. It can return chunks element by element or combine elements with the same metadata, with the objectives of (a) keeping related text grouped (more or less) semantically and (b) preserving context-rich information encoded in document structures. It can be used with other text splitters as part of a chunking pipeline. ## Usage examples[​](#usage-examples "Direct link to Usage examples") #### 1) With an HTML string:[​](#with-an-html-string "Direct link to 1) With an HTML string:") ``` %pip install -qU langchain-text-splitters ``` ``` from langchain_text_splitters import HTMLHeaderTextSplitterhtml_string = """<!DOCTYPE html><html><body> <div> <h1>Foo</h1> <p>Some intro text about Foo.</p> <div> <h2>Bar main section</h2> <p>Some intro text about Bar.</p> <h3>Bar subsection 1</h3> <p>Some text about the first subtopic of Bar.</p> <h3>Bar subsection 2</h3> <p>Some text about the second subtopic of Bar.</p> </div> <div> <h2>Baz</h2> <p>Some text about Baz</p> </div> <br> <p>Some concluding text about Foo</p> </div></body></html>"""headers_to_split_on = [ ("h1", "Header 1"), ("h2", "Header 2"), ("h3", "Header 3"),]html_splitter = HTMLHeaderTextSplitter(headers_to_split_on=headers_to_split_on)html_header_splits = html_splitter.split_text(html_string)html_header_splits ``` ``` [Document(page_content='Foo'), Document(page_content='Some intro text about Foo. \nBar main section Bar subsection 1 Bar subsection 2', metadata={'Header 1': 'Foo'}), Document(page_content='Some intro text about Bar.', metadata={'Header 1': 'Foo', 'Header 2': 'Bar main section'}), Document(page_content='Some text about the first subtopic of Bar.', metadata={'Header 1': 'Foo', 'Header 2': 'Bar main section', 'Header 3': 'Bar subsection 1'}), Document(page_content='Some text about the second subtopic of Bar.', metadata={'Header 1': 'Foo', 'Header 2': 'Bar main section', 'Header 3': 'Bar subsection 2'}), Document(page_content='Baz', metadata={'Header 1': 'Foo'}), Document(page_content='Some text about Baz', metadata={'Header 1': 'Foo', 'Header 2': 'Baz'}), Document(page_content='Some concluding text about Foo', metadata={'Header 1': 'Foo'})] ``` #### 2) Pipelined to another splitter, with html loaded from a web URL:[​](#pipelined-to-another-splitter-with-html-loaded-from-a-web-url "Direct link to 2) Pipelined to another splitter, with html loaded from a web URL:") ``` from langchain_text_splitters import RecursiveCharacterTextSplitterurl = "https://plato.stanford.edu/entries/goedel/"headers_to_split_on = [ ("h1", "Header 1"), ("h2", "Header 2"), ("h3", "Header 3"), ("h4", "Header 4"),]html_splitter = HTMLHeaderTextSplitter(headers_to_split_on=headers_to_split_on)# for local file use html_splitter.split_text_from_file(<path_to_file>)html_header_splits = html_splitter.split_text_from_url(url)chunk_size = 500chunk_overlap = 30text_splitter = RecursiveCharacterTextSplitter( chunk_size=chunk_size, chunk_overlap=chunk_overlap)# Splitsplits = text_splitter.split_documents(html_header_splits)splits[80:85] ``` ``` [Document(page_content='We see that Gödel first tried to reduce the consistency problem for analysis to that of arithmetic. This seemed to require a truth definition for arithmetic, which in turn led to paradoxes, such as the Liar paradox (“This sentence is false”) and Berry’s paradox (“The least number not defined by an expression consisting of just fourteen English words”). Gödel then noticed that such paradoxes would not necessarily arise if truth were replaced by provability. But this means that arithmetic truth', metadata={'Header 1': 'Kurt Gödel', 'Header 2': '2. Gödel’s Mathematical Work', 'Header 3': '2.2 The Incompleteness Theorems', 'Header 4': '2.2.1 The First Incompleteness Theorem'}), Document(page_content='means that arithmetic truth and arithmetic provability are not co-extensive — whence the First Incompleteness Theorem.', metadata={'Header 1': 'Kurt Gödel', 'Header 2': '2. Gödel’s Mathematical Work', 'Header 3': '2.2 The Incompleteness Theorems', 'Header 4': '2.2.1 The First Incompleteness Theorem'}), Document(page_content='This account of Gödel’s discovery was told to Hao Wang very much after the fact; but in Gödel’s contemporary correspondence with Bernays and Zermelo, essentially the same description of his path to the theorems is given. (See Gödel 2003a and Gödel 2003b respectively.) From those accounts we see that the undefinability of truth in arithmetic, a result credited to Tarski, was likely obtained in some form by Gödel by 1931. But he neither publicized nor published the result; the biases logicians', metadata={'Header 1': 'Kurt Gödel', 'Header 2': '2. Gödel’s Mathematical Work', 'Header 3': '2.2 The Incompleteness Theorems', 'Header 4': '2.2.1 The First Incompleteness Theorem'}), Document(page_content='result; the biases logicians had expressed at the time concerning the notion of truth, biases which came vehemently to the fore when Tarski announced his results on the undefinability of truth in formal systems 1935, may have served as a deterrent to Gödel’s publication of that theorem.', metadata={'Header 1': 'Kurt Gödel', 'Header 2': '2. Gödel’s Mathematical Work', 'Header 3': '2.2 The Incompleteness Theorems', 'Header 4': '2.2.1 The First Incompleteness Theorem'}), Document(page_content='We now describe the proof of the two theorems, formulating Gödel’s results in Peano arithmetic. Gödel himself used a system related to that defined in Principia Mathematica, but containing Peano arithmetic. In our presentation of the First and Second Incompleteness Theorems we refer to Peano arithmetic as P, following Gödel’s notation.', metadata={'Header 1': 'Kurt Gödel', 'Header 2': '2. Gödel’s Mathematical Work', 'Header 3': '2.2 The Incompleteness Theorems', 'Header 4': '2.2.2 The proof of the First Incompleteness Theorem'})] ``` ## Limitations[​](#limitations "Direct link to Limitations") There can be quite a bit of structural variation from one HTML document to another, and while `HTMLHeaderTextSplitter` will attempt to attach all “relevant” headers to any given chunk, it can sometimes miss certain headers. For example, the algorithm assumes an informational hierarchy in which headers are always at nodes “above” associated text, i.e. prior siblings, ancestors, and combinations thereof. In the following news article (as of the writing of this document), the document is structured such that the text of the top-level headline, while tagged “h1”, is in a _distinct_ subtree from the text elements that we’d expect it to be _“above”_—so we can observe that the “h1” element and its associated text do not show up in the chunk metadata (but, where applicable, we do see “h2” and its associated text): ``` url = "https://www.cnn.com/2023/09/25/weather/el-nino-winter-us-climate/index.html"headers_to_split_on = [ ("h1", "Header 1"), ("h2", "Header 2"),]html_splitter = HTMLHeaderTextSplitter(headers_to_split_on=headers_to_split_on)html_header_splits = html_splitter.split_text_from_url(url)print(html_header_splits[1].page_content[:500]) ``` ``` No two El Niño winters are the same, but many have temperature and precipitation trends in common. Average conditions during an El Niño winter across the continental US. One of the major reasons is the position of the jet stream, which often shifts south during an El Niño winter. This shift typically brings wetter and cooler weather to the South while the North becomes drier and warmer, according to NOAA. Because the jet stream is essentially a river of air that storms flow through, the ```

Split by HTML header Description and motivation​ Similar in concept to the `MarkdownHeaderTextSplitter`, the `HTMLHeaderTextSplitter` is a “structure-aware” chunker that splits text at the element level and adds metadata for each header “relevant” to any given chunk. It can return chunks element by element or combine elements with the same metadata, with the objectives of (a) keeping related text grouped (more or less) semantically and (b) preserving context-rich information encoded in document structures. It can be used with other text splitters as part of a chunking pipeline. Usage examples​ 1) With an HTML string:​ %pip install -qU langchain-text-splitters from langchain_text_splitters import HTMLHeaderTextSplitter html_string = """ <!DOCTYPE html> <html> <body> <div> <h1>Foo</h1> <p>Some intro text about Foo.</p> <div> <h2>Bar main section</h2> <p>Some intro text about Bar.</p> <h3>Bar subsection 1</h3> <p>Some text about the first subtopic of Bar.</p> <h3>Bar subsection 2</h3> <p>Some text about the second subtopic of Bar.</p> </div> <div> <h2>Baz</h2> <p>Some text about Baz</p> </div> <br> <p>Some concluding text about Foo</p> </div> </body> </html> """ headers_to_split_on = [ ("h1", "Header 1"), ("h2", "Header 2"), ("h3", "Header 3"), ] html_splitter = HTMLHeaderTextSplitter(headers_to_split_on=headers_to_split_on) html_header_splits = html_splitter.split_text(html_string) html_header_splits [Document(page_content='Foo'), Document(page_content='Some intro text about Foo. \nBar main section Bar subsection 1 Bar subsection 2', metadata={'Header 1': 'Foo'}), Document(page_content='Some intro text about Bar.', metadata={'Header 1': 'Foo', 'Header 2': 'Bar main section'}), Document(page_content='Some text about the first subtopic of Bar.', metadata={'Header 1': 'Foo', 'Header 2': 'Bar main section', 'Header 3': 'Bar subsection 1'}), Document(page_content='Some text about the second subtopic of Bar.', metadata={'Header 1': 'Foo', 'Header 2': 'Bar main section', 'Header 3': 'Bar subsection 2'}), Document(page_content='Baz', metadata={'Header 1': 'Foo'}), Document(page_content='Some text about Baz', metadata={'Header 1': 'Foo', 'Header 2': 'Baz'}), Document(page_content='Some concluding text about Foo', metadata={'Header 1': 'Foo'})] 2) Pipelined to another splitter, with html loaded from a web URL:​ from langchain_text_splitters import RecursiveCharacterTextSplitter url = "https://plato.stanford.edu/entries/goedel/" headers_to_split_on = [ ("h1", "Header 1"), ("h2", "Header 2"), ("h3", "Header 3"), ("h4", "Header 4"), ] html_splitter = HTMLHeaderTextSplitter(headers_to_split_on=headers_to_split_on) # for local file use html_splitter.split_text_from_file(<path_to_file>) html_header_splits = html_splitter.split_text_from_url(url) chunk_size = 500 chunk_overlap = 30 text_splitter = RecursiveCharacterTextSplitter( chunk_size=chunk_size, chunk_overlap=chunk_overlap ) # Split splits = text_splitter.split_documents(html_header_splits) splits[80:85] [Document(page_content='We see that Gödel first tried to reduce the consistency problem for analysis to that of arithmetic. This seemed to require a truth definition for arithmetic, which in turn led to paradoxes, such as the Liar paradox (“This sentence is false”) and Berry’s paradox (“The least number not defined by an expression consisting of just fourteen English words”). Gödel then noticed that such paradoxes would not necessarily arise if truth were replaced by provability. But this means that arithmetic truth', metadata={'Header 1': 'Kurt Gödel', 'Header 2': '2. Gödel’s Mathematical Work', 'Header 3': '2.2 The Incompleteness Theorems', 'Header 4': '2.2.1 The First Incompleteness Theorem'}), Document(page_content='means that arithmetic truth and arithmetic provability are not co-extensive — whence the First Incompleteness Theorem.', metadata={'Header 1': 'Kurt Gödel', 'Header 2': '2. Gödel’s Mathematical Work', 'Header 3': '2.2 The Incompleteness Theorems', 'Header 4': '2.2.1 The First Incompleteness Theorem'}), Document(page_content='This account of Gödel’s discovery was told to Hao Wang very much after the fact; but in Gödel’s contemporary correspondence with Bernays and Zermelo, essentially the same description of his path to the theorems is given. (See Gödel 2003a and Gödel 2003b respectively.) From those accounts we see that the undefinability of truth in arithmetic, a result credited to Tarski, was likely obtained in some form by Gödel by 1931. But he neither publicized nor published the result; the biases logicians', metadata={'Header 1': 'Kurt Gödel', 'Header 2': '2. Gödel’s Mathematical Work', 'Header 3': '2.2 The Incompleteness Theorems', 'Header 4': '2.2.1 The First Incompleteness Theorem'}), Document(page_content='result; the biases logicians had expressed at the time concerning the notion of truth, biases which came vehemently to the fore when Tarski announced his results on the undefinability of truth in formal systems 1935, may have served as a deterrent to Gödel’s publication of that theorem.', metadata={'Header 1': 'Kurt Gödel', 'Header 2': '2. Gödel’s Mathematical Work', 'Header 3': '2.2 The Incompleteness Theorems', 'Header 4': '2.2.1 The First Incompleteness Theorem'}), Document(page_content='We now describe the proof of the two theorems, formulating Gödel’s results in Peano arithmetic. Gödel himself used a system related to that defined in Principia Mathematica, but containing Peano arithmetic. In our presentation of the First and Second Incompleteness Theorems we refer to Peano arithmetic as P, following Gödel’s notation.', metadata={'Header 1': 'Kurt Gödel', 'Header 2': '2. Gödel’s Mathematical Work', 'Header 3': '2.2 The Incompleteness Theorems', 'Header 4': '2.2.2 The proof of the First Incompleteness Theorem'})] Limitations​ There can be quite a bit of structural variation from one HTML document to another, and while HTMLHeaderTextSplitter will attempt to attach all “relevant” headers to any given chunk, it can sometimes miss certain headers. For example, the algorithm assumes an informational hierarchy in which headers are always at nodes “above” associated text, i.e. prior siblings, ancestors, and combinations thereof. In the following news article (as of the writing of this document), the document is structured such that the text of the top-level headline, while tagged “h1”, is in a distinct subtree from the text elements that we’d expect it to be “above”—so we can observe that the “h1” element and its associated text do not show up in the chunk metadata (but, where applicable, we do see “h2” and its associated text): url = "https://www.cnn.com/2023/09/25/weather/el-nino-winter-us-climate/index.html" headers_to_split_on = [ ("h1", "Header 1"), ("h2", "Header 2"), ] html_splitter = HTMLHeaderTextSplitter(headers_to_split_on=headers_to_split_on) html_header_splits = html_splitter.split_text_from_url(url) print(html_header_splits[1].page_content[:500]) No two El Niño winters are the same, but many have temperature and precipitation trends in common. Average conditions during an El Niño winter across the continental US. One of the major reasons is the position of the jet stream, which often shifts south during an El Niño winter. This shift typically brings wetter and cooler weather to the South while the North becomes drier and warmer, according to NOAA. Because the jet stream is essentially a river of air that storms flow through, the

https://python.langchain.com/docs/modules/data_connection/document_transformers/HTML_section_aware_splitter/

Similar in concept to the [HTMLHeaderTextSplitter](https://python.langchain.com/docs/modules/data_connection/document_transformers/HTML_header_metadata/), the `HTMLSectionSplitter` is a “structure-aware” chunker that splits text at the element level and adds metadata for each header “relevant” to any given chunk. It can return chunks element by element or combine elements with the same metadata, with the objectives of (a) keeping related text grouped (more or less) semantically and (b) preserving context-rich information encoded in document structures. It can be used with other text splitters as part of a chunking pipeline. Internally, it uses the `RecursiveCharacterTextSplitter` when the section size is larger than the chunk size. It also considers the font size of the text to determine whether it is a section or not based on the determined font size threshold. Use `xslt_path` to provide an absolute path to transform the HTML so that it can detect sections based on provided tags. The default is to use the `converting_to_header.xslt` file in the `data_connection/document_transformers` directory. This is for converting the html to a format/layout that is easier to detect sections. For example, `span` based on their font size can be converted to header tags to be detected as a section. ``` from langchain_text_splitters import HTMLSectionSplitterhtml_string = """ <!DOCTYPE html> <html> <body> <div> <h1>Foo</h1> <p>Some intro text about Foo.</p> <div> <h2>Bar main section</h2> <p>Some intro text about Bar.</p> <h3>Bar subsection 1</h3> <p>Some text about the first subtopic of Bar.</p> <h3>Bar subsection 2</h3> <p>Some text about the second subtopic of Bar.</p> </div> <div> <h2>Baz</h2> <p>Some text about Baz</p> </div> <br> <p>Some concluding text about Foo</p> </div> </body> </html>"""headers_to_split_on = [("h1", "Header 1"), ("h2", "Header 2")]html_splitter = HTMLSectionSplitter(headers_to_split_on=headers_to_split_on)html_header_splits = html_splitter.split_text(html_string)html_header_splits ``` ``` from langchain.text_splitter import RecursiveCharacterTextSplitterhtml_string = """ <!DOCTYPE html> <html> <body> <div> <h1>Foo</h1> <p>Some intro text about Foo.</p> <div> <h2>Bar main section</h2> <p>Some intro text about Bar.</p> <h3>Bar subsection 1</h3> <p>Some text about the first subtopic of Bar.</p> <h3>Bar subsection 2</h3> <p>Some text about the second subtopic of Bar.</p> </div> <div> <h2>Baz</h2> <p>Some text about Baz</p> </div> <br> <p>Some concluding text about Foo</p> </div> </body> </html>"""headers_to_split_on = [ ("h1", "Header 1"), ("h2", "Header 2"), ("h3", "Header 3"), ("h4", "Header 4"),]html_splitter = HTMLSectionSplitter(headers_to_split_on=headers_to_split_on)html_header_splits = html_splitter.split_text(html_string)chunk_size = 500chunk_overlap = 30text_splitter = RecursiveCharacterTextSplitter( chunk_size=chunk_size, chunk_overlap=chunk_overlap)# Splitsplits = text_splitter.split_documents(html_header_splits)splits ```

Similar in concept to the HTMLHeaderTextSplitter, the HTMLSectionSplitter is a “structure-aware” chunker that splits text at the element level and adds metadata for each header “relevant” to any given chunk. It can return chunks element by element or combine elements with the same metadata, with the objectives of (a) keeping related text grouped (more or less) semantically and (b) preserving context-rich information encoded in document structures. It can be used with other text splitters as part of a chunking pipeline. Internally, it uses the RecursiveCharacterTextSplitter when the section size is larger than the chunk size. It also considers the font size of the text to determine whether it is a section or not based on the determined font size threshold. Use xslt_path to provide an absolute path to transform the HTML so that it can detect sections based on provided tags. The default is to use the converting_to_header.xslt file in the data_connection/document_transformers directory. This is for converting the html to a format/layout that is easier to detect sections. For example, span based on their font size can be converted to header tags to be detected as a section. from langchain_text_splitters import HTMLSectionSplitter html_string = """ <!DOCTYPE html> <html> <body> <div> <h1>Foo</h1> <p>Some intro text about Foo.</p> <div> <h2>Bar main section</h2> <p>Some intro text about Bar.</p> <h3>Bar subsection 1</h3> <p>Some text about the first subtopic of Bar.</p> <h3>Bar subsection 2</h3> <p>Some text about the second subtopic of Bar.</p> </div> <div> <h2>Baz</h2> <p>Some text about Baz</p> </div> <br> <p>Some concluding text about Foo</p> </div> </body> </html> """ headers_to_split_on = [("h1", "Header 1"), ("h2", "Header 2")] html_splitter = HTMLSectionSplitter(headers_to_split_on=headers_to_split_on) html_header_splits = html_splitter.split_text(html_string) html_header_splits from langchain.text_splitter import RecursiveCharacterTextSplitter html_string = """ <!DOCTYPE html> <html> <body> <div> <h1>Foo</h1> <p>Some intro text about Foo.</p> <div> <h2>Bar main section</h2> <p>Some intro text about Bar.</p> <h3>Bar subsection 1</h3> <p>Some text about the first subtopic of Bar.</p> <h3>Bar subsection 2</h3> <p>Some text about the second subtopic of Bar.</p> </div> <div> <h2>Baz</h2> <p>Some text about Baz</p> </div> <br> <p>Some concluding text about Foo</p> </div> </body> </html> """ headers_to_split_on = [ ("h1", "Header 1"), ("h2", "Header 2"), ("h3", "Header 3"), ("h4", "Header 4"), ] html_splitter = HTMLSectionSplitter(headers_to_split_on=headers_to_split_on) html_header_splits = html_splitter.split_text(html_string) chunk_size = 500 chunk_overlap = 30 text_splitter = RecursiveCharacterTextSplitter( chunk_size=chunk_size, chunk_overlap=chunk_overlap ) # Split splits = text_splitter.split_documents(html_header_splits) splits

https://python.langchain.com/docs/modules/data_connection/document_transformers/markdown_header_metadata/

## MarkdownHeaderTextSplitter ### Motivation[​](#motivation "Direct link to Motivation") Many chat or Q+A applications involve chunking input documents prior to embedding and vector storage. [These notes](https://www.pinecone.io/learn/chunking-strategies/) from Pinecone provide some useful tips: ``` When a full paragraph or document is embedded, the embedding process considers both the overall context and the relationships between the sentences and phrases within the text. This can result in a more comprehensive vector representation that captures the broader meaning and themes of the text. ``` As mentioned, chunking often aims to keep text with common context together. With this in mind, we might want to specifically honor the structure of the document itself. For example, a markdown file is organized by headers. Creating chunks within specific header groups is an intuitive idea. To address this challenge, we can use `MarkdownHeaderTextSplitter`. This will split a markdown file by a specified set of headers. For example, if we want to split this markdown: ``` md = '# Foo\n\n ## Bar\n\nHi this is Jim \nHi this is Joe\n\n ## Baz\n\n Hi this is Molly' ``` We can specify the headers to split on: ``` [("#", "Header 1"),("##", "Header 2")] ``` And content is grouped or split by common headers: ``` {'content': 'Hi this is Jim \nHi this is Joe', 'metadata': {'Header 1': 'Foo', 'Header 2': 'Bar'}}{'content': 'Hi this is Molly', 'metadata': {'Header 1': 'Foo', 'Header 2': 'Baz'}} ``` Let’s have a look at some examples below. ``` %pip install -qU langchain-text-splitters ``` ``` from langchain_text_splitters import MarkdownHeaderTextSplitter ``` ``` markdown_document = "# Foo\n\n ## Bar\n\nHi this is Jim\n\nHi this is Joe\n\n ### Boo \n\n Hi this is Lance \n\n ## Baz\n\n Hi this is Molly"headers_to_split_on = [ ("#", "Header 1"), ("##", "Header 2"), ("###", "Header 3"),]markdown_splitter = MarkdownHeaderTextSplitter(headers_to_split_on=headers_to_split_on)md_header_splits = markdown_splitter.split_text(markdown_document)md_header_splits ``` ``` [Document(page_content='Hi this is Jim \nHi this is Joe', metadata={'Header 1': 'Foo', 'Header 2': 'Bar'}), Document(page_content='Hi this is Lance', metadata={'Header 1': 'Foo', 'Header 2': 'Bar', 'Header 3': 'Boo'}), Document(page_content='Hi this is Molly', metadata={'Header 1': 'Foo', 'Header 2': 'Baz'})] ``` ``` type(md_header_splits[0]) ``` ``` langchain.schema.document.Document ``` By default, `MarkdownHeaderTextSplitter` strips headers being split on from the output chunk’s content. This can be disabled by setting `strip_headers = False`. ``` markdown_splitter = MarkdownHeaderTextSplitter( headers_to_split_on=headers_to_split_on, strip_headers=False)md_header_splits = markdown_splitter.split_text(markdown_document)md_header_splits ``` ``` [Document(page_content='# Foo \n## Bar \nHi this is Jim \nHi this is Joe', metadata={'Header 1': 'Foo', 'Header 2': 'Bar'}), Document(page_content='### Boo \nHi this is Lance', metadata={'Header 1': 'Foo', 'Header 2': 'Bar', 'Header 3': 'Boo'}), Document(page_content='## Baz \nHi this is Molly', metadata={'Header 1': 'Foo', 'Header 2': 'Baz'})] ``` Within each markdown group we can then apply any text splitter we want. ``` markdown_document = "# Intro \n\n ## History \n\n Markdown[9] is a lightweight markup language for creating formatted text using a plain-text editor. John Gruber created Markdown in 2004 as a markup language that is appealing to human readers in its source code form.[9] \n\n Markdown is widely used in blogging, instant messaging, online forums, collaborative software, documentation pages, and readme files. \n\n ## Rise and divergence \n\n As Markdown popularity grew rapidly, many Markdown implementations appeared, driven mostly by the need for \n\n additional features such as tables, footnotes, definition lists,[note 1] and Markdown inside HTML blocks. \n\n #### Standardization \n\n From 2012, a group of people, including Jeff Atwood and John MacFarlane, launched what Atwood characterised as a standardisation effort. \n\n ## Implementations \n\n Implementations of Markdown are available for over a dozen programming languages."headers_to_split_on = [ ("#", "Header 1"), ("##", "Header 2"),]# MD splitsmarkdown_splitter = MarkdownHeaderTextSplitter( headers_to_split_on=headers_to_split_on, strip_headers=False)md_header_splits = markdown_splitter.split_text(markdown_document)# Char-level splitsfrom langchain_text_splitters import RecursiveCharacterTextSplitterchunk_size = 250chunk_overlap = 30text_splitter = RecursiveCharacterTextSplitter( chunk_size=chunk_size, chunk_overlap=chunk_overlap)# Splitsplits = text_splitter.split_documents(md_header_splits)splits ``` ``` [Document(page_content='# Intro \n## History \nMarkdown[9] is a lightweight markup language for creating formatted text using a plain-text editor. John Gruber created Markdown in 2004 as a markup language that is appealing to human readers in its source code form.[9]', metadata={'Header 1': 'Intro', 'Header 2': 'History'}), Document(page_content='Markdown is widely used in blogging, instant messaging, online forums, collaborative software, documentation pages, and readme files.', metadata={'Header 1': 'Intro', 'Header 2': 'History'}), Document(page_content='## Rise and divergence \nAs Markdown popularity grew rapidly, many Markdown implementations appeared, driven mostly by the need for \nadditional features such as tables, footnotes, definition lists,[note 1] and Markdown inside HTML blocks.', metadata={'Header 1': 'Intro', 'Header 2': 'Rise and divergence'}), Document(page_content='#### Standardization \nFrom 2012, a group of people, including Jeff Atwood and John MacFarlane, launched what Atwood characterised as a standardisation effort.', metadata={'Header 1': 'Intro', 'Header 2': 'Rise and divergence'}), Document(page_content='## Implementations \nImplementations of Markdown are available for over a dozen programming languages.', metadata={'Header 1': 'Intro', 'Header 2': 'Implementations'})] ```

MarkdownHeaderTextSplitter Motivation​ Many chat or Q+A applications involve chunking input documents prior to embedding and vector storage. These notes from Pinecone provide some useful tips: When a full paragraph or document is embedded, the embedding process considers both the overall context and the relationships between the sentences and phrases within the text. This can result in a more comprehensive vector representation that captures the broader meaning and themes of the text. As mentioned, chunking often aims to keep text with common context together. With this in mind, we might want to specifically honor the structure of the document itself. For example, a markdown file is organized by headers. Creating chunks within specific header groups is an intuitive idea. To address this challenge, we can use MarkdownHeaderTextSplitter. This will split a markdown file by a specified set of headers. For example, if we want to split this markdown: md = '# Foo\n\n ## Bar\n\nHi this is Jim \nHi this is Joe\n\n ## Baz\n\n Hi this is Molly' We can specify the headers to split on: [("#", "Header 1"),("##", "Header 2")] And content is grouped or split by common headers: {'content': 'Hi this is Jim \nHi this is Joe', 'metadata': {'Header 1': 'Foo', 'Header 2': 'Bar'}} {'content': 'Hi this is Molly', 'metadata': {'Header 1': 'Foo', 'Header 2': 'Baz'}} Let’s have a look at some examples below. %pip install -qU langchain-text-splitters from langchain_text_splitters import MarkdownHeaderTextSplitter markdown_document = "# Foo\n\n ## Bar\n\nHi this is Jim\n\nHi this is Joe\n\n ### Boo \n\n Hi this is Lance \n\n ## Baz\n\n Hi this is Molly" headers_to_split_on = [ ("#", "Header 1"), ("##", "Header 2"), ("###", "Header 3"), ] markdown_splitter = MarkdownHeaderTextSplitter(headers_to_split_on=headers_to_split_on) md_header_splits = markdown_splitter.split_text(markdown_document) md_header_splits [Document(page_content='Hi this is Jim \nHi this is Joe', metadata={'Header 1': 'Foo', 'Header 2': 'Bar'}), Document(page_content='Hi this is Lance', metadata={'Header 1': 'Foo', 'Header 2': 'Bar', 'Header 3': 'Boo'}), Document(page_content='Hi this is Molly', metadata={'Header 1': 'Foo', 'Header 2': 'Baz'})] type(md_header_splits[0]) langchain.schema.document.Document By default, MarkdownHeaderTextSplitter strips headers being split on from the output chunk’s content. This can be disabled by setting strip_headers = False. markdown_splitter = MarkdownHeaderTextSplitter( headers_to_split_on=headers_to_split_on, strip_headers=False ) md_header_splits = markdown_splitter.split_text(markdown_document) md_header_splits [Document(page_content='# Foo \n## Bar \nHi this is Jim \nHi this is Joe', metadata={'Header 1': 'Foo', 'Header 2': 'Bar'}), Document(page_content='### Boo \nHi this is Lance', metadata={'Header 1': 'Foo', 'Header 2': 'Bar', 'Header 3': 'Boo'}), Document(page_content='## Baz \nHi this is Molly', metadata={'Header 1': 'Foo', 'Header 2': 'Baz'})] Within each markdown group we can then apply any text splitter we want. markdown_document = "# Intro \n\n ## History \n\n Markdown[9] is a lightweight markup language for creating formatted text using a plain-text editor. John Gruber created Markdown in 2004 as a markup language that is appealing to human readers in its source code form.[9] \n\n Markdown is widely used in blogging, instant messaging, online forums, collaborative software, documentation pages, and readme files. \n\n ## Rise and divergence \n\n As Markdown popularity grew rapidly, many Markdown implementations appeared, driven mostly by the need for \n\n additional features such as tables, footnotes, definition lists,[note 1] and Markdown inside HTML blocks. \n\n #### Standardization \n\n From 2012, a group of people, including Jeff Atwood and John MacFarlane, launched what Atwood characterised as a standardisation effort. \n\n ## Implementations \n\n Implementations of Markdown are available for over a dozen programming languages." headers_to_split_on = [ ("#", "Header 1"), ("##", "Header 2"), ] # MD splits markdown_splitter = MarkdownHeaderTextSplitter( headers_to_split_on=headers_to_split_on, strip_headers=False ) md_header_splits = markdown_splitter.split_text(markdown_document) # Char-level splits from langchain_text_splitters import RecursiveCharacterTextSplitter chunk_size = 250 chunk_overlap = 30 text_splitter = RecursiveCharacterTextSplitter( chunk_size=chunk_size, chunk_overlap=chunk_overlap ) # Split splits = text_splitter.split_documents(md_header_splits) splits [Document(page_content='# Intro \n## History \nMarkdown[9] is a lightweight markup language for creating formatted text using a plain-text editor. John Gruber created Markdown in 2004 as a markup language that is appealing to human readers in its source code form.[9]', metadata={'Header 1': 'Intro', 'Header 2': 'History'}), Document(page_content='Markdown is widely used in blogging, instant messaging, online forums, collaborative software, documentation pages, and readme files.', metadata={'Header 1': 'Intro', 'Header 2': 'History'}), Document(page_content='## Rise and divergence \nAs Markdown popularity grew rapidly, many Markdown implementations appeared, driven mostly by the need for \nadditional features such as tables, footnotes, definition lists,[note 1] and Markdown inside HTML blocks.', metadata={'Header 1': 'Intro', 'Header 2': 'Rise and divergence'}), Document(page_content='#### Standardization \nFrom 2012, a group of people, including Jeff Atwood and John MacFarlane, launched what Atwood characterised as a standardisation effort.', metadata={'Header 1': 'Intro', 'Header 2': 'Rise and divergence'}), Document(page_content='## Implementations \nImplementations of Markdown are available for over a dozen programming languages.', metadata={'Header 1': 'Intro', 'Header 2': 'Implementations'})]

https://python.langchain.com/docs/modules/data_connection/document_transformers/recursive_json_splitter/

## Recursively split JSON This json splitter traverses json data depth first and builds smaller json chunks. It attempts to keep nested json objects whole but will split them if needed to keep chunks between a min\_chunk\_size and the max\_chunk\_size. If the value is not a nested json, but rather a very large string the string will not be split. If you need a hard cap on the chunk size considder following this with a Recursive Text splitter on those chunks. There is an optional pre-processing step to split lists, by first converting them to json (dict) and then splitting them as such. 1. How the text is split: json value. 2. How the chunk size is measured: by number of characters. ``` %pip install -qU langchain-text-splitters ``` ``` import jsonimport requests ``` ``` # This is a large nested json object and will be loaded as a python dictjson_data = requests.get("https://api.smith.langchain.com/openapi.json").json() ``` ``` from langchain_text_splitters import RecursiveJsonSplitter ``` ``` splitter = RecursiveJsonSplitter(max_chunk_size=300) ``` ``` # Recursively split json data - If you need to access/manipulate the smaller json chunksjson_chunks = splitter.split_json(json_data=json_data) ``` ``` # The splitter can also output documentsdocs = splitter.create_documents(texts=[json_data])# or a list of stringstexts = splitter.split_text(json_data=json_data)print(texts[0])print(texts[1]) ``` ``` {"openapi": "3.0.2", "info": {"title": "LangChainPlus", "version": "0.1.0"}, "paths": {"/sessions/{session_id}": {"get": {"tags": ["tracer-sessions"], "summary": "Read Tracer Session", "description": "Get a specific session.", "operationId": "read_tracer_session_sessions__session_id__get"}}}}{"paths": {"/sessions/{session_id}": {"get": {"parameters": [{"required": true, "schema": {"title": "Session Id", "type": "string", "format": "uuid"}, "name": "session_id", "in": "path"}, {"required": false, "schema": {"title": "Include Stats", "type": "boolean", "default": false}, "name": "include_stats", "in": "query"}, {"required": false, "schema": {"title": "Accept", "type": "string"}, "name": "accept", "in": "header"}]}}}} ``` ``` # Let's look at the size of the chunksprint([len(text) for text in texts][:10])# Reviewing one of these chunks that was bigger we see there is a list object thereprint(texts[1]) ``` ``` [293, 431, 203, 277, 230, 194, 162, 280, 223, 193]{"paths": {"/sessions/{session_id}": {"get": {"parameters": [{"required": true, "schema": {"title": "Session Id", "type": "string", "format": "uuid"}, "name": "session_id", "in": "path"}, {"required": false, "schema": {"title": "Include Stats", "type": "boolean", "default": false}, "name": "include_stats", "in": "query"}, {"required": false, "schema": {"title": "Accept", "type": "string"}, "name": "accept", "in": "header"}]}}}} ``` ``` # The json splitter by default does not split lists# the following will preprocess the json and convert list to dict with index:item as key:val pairstexts = splitter.split_text(json_data=json_data, convert_lists=True) ``` ``` # Let's look at the size of the chunks. Now they are all under the maxprint([len(text) for text in texts][:10]) ``` ``` [293, 431, 203, 277, 230, 194, 162, 280, 223, 193] ``` ``` # The list has been converted to a dict, but retains all the needed contextual information even if split into many chunksprint(texts[1]) ``` ``` {"paths": {"/sessions/{session_id}": {"get": {"parameters": [{"required": true, "schema": {"title": "Session Id", "type": "string", "format": "uuid"}, "name": "session_id", "in": "path"}, {"required": false, "schema": {"title": "Include Stats", "type": "boolean", "default": false}, "name": "include_stats", "in": "query"}, {"required": false, "schema": {"title": "Accept", "type": "string"}, "name": "accept", "in": "header"}]}}}} ``` ``` # We can also look at the documentsdocs[1] ``` ``` Document(page_content='{"paths": {"/sessions/{session_id}": {"get": {"parameters": [{"required": true, "schema": {"title": "Session Id", "type": "string", "format": "uuid"}, "name": "session_id", "in": "path"}, {"required": false, "schema": {"title": "Include Stats", "type": "boolean", "default": false}, "name": "include_stats", "in": "query"}, {"required": false, "schema": {"title": "Accept", "type": "string"}, "name": "accept", "in": "header"}]}}}}') ```

Recursively split JSON This json splitter traverses json data depth first and builds smaller json chunks. It attempts to keep nested json objects whole but will split them if needed to keep chunks between a min_chunk_size and the max_chunk_size. If the value is not a nested json, but rather a very large string the string will not be split. If you need a hard cap on the chunk size considder following this with a Recursive Text splitter on those chunks. There is an optional pre-processing step to split lists, by first converting them to json (dict) and then splitting them as such. How the text is split: json value. How the chunk size is measured: by number of characters. %pip install -qU langchain-text-splitters import json import requests # This is a large nested json object and will be loaded as a python dict json_data = requests.get("https://api.smith.langchain.com/openapi.json").json() from langchain_text_splitters import RecursiveJsonSplitter splitter = RecursiveJsonSplitter(max_chunk_size=300) # Recursively split json data - If you need to access/manipulate the smaller json chunks json_chunks = splitter.split_json(json_data=json_data) # The splitter can also output documents docs = splitter.create_documents(texts=[json_data]) # or a list of strings texts = splitter.split_text(json_data=json_data) print(texts[0]) print(texts[1]) {"openapi": "3.0.2", "info": {"title": "LangChainPlus", "version": "0.1.0"}, "paths": {"/sessions/{session_id}": {"get": {"tags": ["tracer-sessions"], "summary": "Read Tracer Session", "description": "Get a specific session.", "operationId": "read_tracer_session_sessions__session_id__get"}}}} {"paths": {"/sessions/{session_id}": {"get": {"parameters": [{"required": true, "schema": {"title": "Session Id", "type": "string", "format": "uuid"}, "name": "session_id", "in": "path"}, {"required": false, "schema": {"title": "Include Stats", "type": "boolean", "default": false}, "name": "include_stats", "in": "query"}, {"required": false, "schema": {"title": "Accept", "type": "string"}, "name": "accept", "in": "header"}]}}}} # Let's look at the size of the chunks print([len(text) for text in texts][:10]) # Reviewing one of these chunks that was bigger we see there is a list object there print(texts[1]) [293, 431, 203, 277, 230, 194, 162, 280, 223, 193] {"paths": {"/sessions/{session_id}": {"get": {"parameters": [{"required": true, "schema": {"title": "Session Id", "type": "string", "format": "uuid"}, "name": "session_id", "in": "path"}, {"required": false, "schema": {"title": "Include Stats", "type": "boolean", "default": false}, "name": "include_stats", "in": "query"}, {"required": false, "schema": {"title": "Accept", "type": "string"}, "name": "accept", "in": "header"}]}}}} # The json splitter by default does not split lists # the following will preprocess the json and convert list to dict with index:item as key:val pairs texts = splitter.split_text(json_data=json_data, convert_lists=True) # Let's look at the size of the chunks. Now they are all under the max print([len(text) for text in texts][:10]) [293, 431, 203, 277, 230, 194, 162, 280, 223, 193] # The list has been converted to a dict, but retains all the needed contextual information even if split into many chunks print(texts[1]) {"paths": {"/sessions/{session_id}": {"get": {"parameters": [{"required": true, "schema": {"title": "Session Id", "type": "string", "format": "uuid"}, "name": "session_id", "in": "path"}, {"required": false, "schema": {"title": "Include Stats", "type": "boolean", "default": false}, "name": "include_stats", "in": "query"}, {"required": false, "schema": {"title": "Accept", "type": "string"}, "name": "accept", "in": "header"}]}}}} # We can also look at the documents docs[1] Document(page_content='{"paths": {"/sessions/{session_id}": {"get": {"parameters": [{"required": true, "schema": {"title": "Session Id", "type": "string", "format": "uuid"}, "name": "session_id", "in": "path"}, {"required": false, "schema": {"title": "Include Stats", "type": "boolean", "default": false}, "name": "include_stats", "in": "query"}, {"required": false, "schema": {"title": "Accept", "type": "string"}, "name": "accept", "in": "header"}]}}}}')

https://python.langchain.com/docs/modules/agents/how_to/intermediate_steps/

## Access intermediate steps In order to get more visibility into what an agent is doing, we can also return intermediate steps. This comes in the form of an extra key in the return value, which is a list of (action, observation) tuples. ``` from langchain import hubfrom langchain.agents import AgentExecutor, create_openai_functions_agentfrom langchain_community.tools import WikipediaQueryRunfrom langchain_community.utilities import WikipediaAPIWrapperfrom langchain_openai import ChatOpenAIapi_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=100)tool = WikipediaQueryRun(api_wrapper=api_wrapper)tools = [tool]# Get the prompt to use - you can modify this!# If you want to see the prompt in full, you can at: https://smith.langchain.com/hub/hwchase17/openai-functions-agentprompt = hub.pull("hwchase17/openai-functions-agent")llm = ChatOpenAI(temperature=0)agent = create_openai_functions_agent(llm, tools, prompt) ``` Initialize the AgentExecutor with `return_intermediate_steps=True`: ``` agent_executor = AgentExecutor( agent=agent, tools=tools, verbose=True, return_intermediate_steps=True) ``` ``` response = agent_executor.invoke({"input": "What is Leo DiCaprio's middle name?"}) ``` ``` > Entering new AgentExecutor chain...Invoking: `Wikipedia` with `Leo DiCaprio`Page: Leonardo DiCaprioSummary: Leonardo Wilhelm DiCaprio (; Italian: [diˈkaːprjo]; born November 1Leonardo DiCaprio's middle name is Wilhelm.> Finished chain. ``` ``` # The actual return type is a NamedTuple for the agent action, and then an observationprint(response["intermediate_steps"]) ``` ``` [(AgentActionMessageLog(tool='Wikipedia', tool_input='Leo DiCaprio', log='\nInvoking: `Wikipedia` with `Leo DiCaprio`\n\n\n', message_log=[AIMessage(content='', additional_kwargs={'function_call': {'name': 'Wikipedia', 'arguments': '{\n "__arg1": "Leo DiCaprio"\n}'}})]), 'Page: Leonardo DiCaprio\nSummary: Leonardo Wilhelm DiCaprio (; Italian: [diˈkaːprjo]; born November 1')] ``` * * * #### Help us out by providing feedback on this documentation page:

Access intermediate steps In order to get more visibility into what an agent is doing, we can also return intermediate steps. This comes in the form of an extra key in the return value, which is a list of (action, observation) tuples. from langchain import hub from langchain.agents import AgentExecutor, create_openai_functions_agent from langchain_community.tools import WikipediaQueryRun from langchain_community.utilities import WikipediaAPIWrapper from langchain_openai import ChatOpenAI api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=100) tool = WikipediaQueryRun(api_wrapper=api_wrapper) tools = [tool] # Get the prompt to use - you can modify this! # If you want to see the prompt in full, you can at: https://smith.langchain.com/hub/hwchase17/openai-functions-agent prompt = hub.pull("hwchase17/openai-functions-agent") llm = ChatOpenAI(temperature=0) agent = create_openai_functions_agent(llm, tools, prompt) Initialize the AgentExecutor with return_intermediate_steps=True: agent_executor = AgentExecutor( agent=agent, tools=tools, verbose=True, return_intermediate_steps=True ) response = agent_executor.invoke({"input": "What is Leo DiCaprio's middle name?"}) > Entering new AgentExecutor chain... Invoking: `Wikipedia` with `Leo DiCaprio` Page: Leonardo DiCaprio Summary: Leonardo Wilhelm DiCaprio (; Italian: [diˈkaːprjo]; born November 1Leonardo DiCaprio's middle name is Wilhelm. > Finished chain. # The actual return type is a NamedTuple for the agent action, and then an observation print(response["intermediate_steps"]) [(AgentActionMessageLog(tool='Wikipedia', tool_input='Leo DiCaprio', log='\nInvoking: `Wikipedia` with `Leo DiCaprio`\n\n\n', message_log=[AIMessage(content='', additional_kwargs={'function_call': {'name': 'Wikipedia', 'arguments': '{\n "__arg1": "Leo DiCaprio"\n}'}})]), 'Page: Leonardo DiCaprio\nSummary: Leonardo Wilhelm DiCaprio (; Italian: [diˈkaːprjo]; born November 1')] Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/modules/data_connection/document_transformers/split_by_token/

## Split by tokens Language models have a token limit. You should not exceed the token limit. When you split your text into chunks it is therefore a good idea to count the number of tokens. There are many tokenizers. When you count tokens in your text you should use the same tokenizer as used in the language model. ## tiktoken[​](#tiktoken "Direct link to tiktoken") > [tiktoken](https://github.com/openai/tiktoken) is a fast `BPE` tokenizer created by `OpenAI`. We can use it to estimate tokens used. It will probably be more accurate for the OpenAI models. 1. How the text is split: by character passed in. 2. How the chunk size is measured: by `tiktoken` tokenizer. ``` %pip install --upgrade --quiet langchain-text-splitters tiktoken ``` ``` # This is a long document we can split up.with open("../../state_of_the_union.txt") as f: state_of_the_union = f.read()from langchain_text_splitters import CharacterTextSplitter ``` The `.from_tiktoken_encoder()` method takes either `encoding` as an argument (e.g. `cl100k_base`), or the `model_name` (e.g. `gpt-4`). All additional arguments like `chunk_size`, `chunk_overlap`, and `separators` are used to instantiate `CharacterTextSplitter`: ``` text_splitter = CharacterTextSplitter.from_tiktoken_encoder( encoding="cl100k_base", chunk_size=100, chunk_overlap=0)texts = text_splitter.split_text(state_of_the_union) ``` ``` Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. Last year COVID-19 kept us apart. This year we are finally together again. Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. With a duty to one another to the American people to the Constitution. ``` Note that if we use `CharacterTextSplitter.from_tiktoken_encoder`, text is only split by `CharacterTextSplitter` and `tiktoken` tokenizer is used to merge splits. It means that split can be larger than chunk size measured by `tiktoken` tokenizer. We can use `RecursiveCharacterTextSplitter.from_tiktoken_encoder` to make sure splits are not larger than chunk size of tokens allowed by the language model, where each split will be recursively split if it has a larger size: ``` from langchain_text_splitters import RecursiveCharacterTextSplittertext_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder( model_name="gpt-4", chunk_size=100, chunk_overlap=0,) ``` We can also load a tiktoken splitter directly, which will ensure each split is smaller than chunk size. ``` from langchain_text_splitters import TokenTextSplittertext_splitter = TokenTextSplitter(chunk_size=10, chunk_overlap=0)texts = text_splitter.split_text(state_of_the_union)print(texts[0]) ``` Some written languages (e.g. Chinese and Japanese) have characters which encode to 2 or more tokens. Using the `TokenTextSplitter` directly can split the tokens for a character between two chunks causing malformed Unicode characters. Use `RecursiveCharacterTextSplitter.from_tiktoken_encoder` or `CharacterTextSplitter.from_tiktoken_encoder` to ensure chunks contain valid Unicode strings. ## spaCy[​](#spacy "Direct link to spaCy") > [spaCy](https://spacy.io/) is an open-source software library for advanced natural language processing, written in the programming languages Python and Cython. Another alternative to `NLTK` is to use [spaCy tokenizer](https://spacy.io/api/tokenizer). 1. How the text is split: by `spaCy` tokenizer. 2. How the chunk size is measured: by number of characters. ``` %pip install --upgrade --quiet spacy ``` ``` # This is a long document we can split up.with open("../../state_of_the_union.txt") as f: state_of_the_union = f.read() ``` ``` from langchain_text_splitters import SpacyTextSplittertext_splitter = SpacyTextSplitter(chunk_size=1000) ``` ``` texts = text_splitter.split_text(state_of_the_union)print(texts[0]) ``` ``` Madam Speaker, Madam Vice President, our First Lady and Second Gentleman.Members of Congress and the Cabinet.Justices of the Supreme Court.My fellow Americans. Last year COVID-19 kept us apart.This year we are finally together again. Tonight, we meet as Democrats Republicans and Independents.But most importantly as Americans. With a duty to one another to the American people to the Constitution. And with an unwavering resolve that freedom will always triumph over tyranny. Six days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways.But he badly miscalculated. He thought he could roll into Ukraine and the world would roll over.Instead he met a wall of strength he never imagined. He met the Ukrainian people. From President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world. ``` ## SentenceTransformers[​](#sentencetransformers "Direct link to SentenceTransformers") The `SentenceTransformersTokenTextSplitter` is a specialized text splitter for use with the sentence-transformer models. The default behaviour is to split the text into chunks that fit the token window of the sentence transformer model that you would like to use. ``` from langchain_text_splitters import SentenceTransformersTokenTextSplitter ``` ``` splitter = SentenceTransformersTokenTextSplitter(chunk_overlap=0)text = "Lorem " ``` ``` count_start_and_stop_tokens = 2text_token_count = splitter.count_tokens(text=text) - count_start_and_stop_tokensprint(text_token_count) ``` ``` token_multiplier = splitter.maximum_tokens_per_chunk // text_token_count + 1# `text_to_split` does not fit in a single chunktext_to_split = text * token_multiplierprint(f"tokens in text to split: {splitter.count_tokens(text=text_to_split)}") ``` ``` tokens in text to split: 514 ``` ``` text_chunks = splitter.split_text(text=text_to_split)print(text_chunks[1]) ``` ## NLTK[​](#nltk "Direct link to NLTK") > [The Natural Language Toolkit](https://en.wikipedia.org/wiki/Natural_Language_Toolkit), or more commonly [NLTK](https://www.nltk.org/), is a suite of libraries and programs for symbolic and statistical natural language processing (NLP) for English written in the Python programming language. Rather than just splitting on “”, we can use `NLTK` to split based on [NLTK tokenizers](https://www.nltk.org/api/nltk.tokenize.html). 1. How the text is split: by `NLTK` tokenizer. 2. How the chunk size is measured: by number of characters. ``` # This is a long document we can split up.with open("../../state_of_the_union.txt") as f: state_of_the_union = f.read() ``` ``` from langchain_text_splitters import NLTKTextSplittertext_splitter = NLTKTextSplitter(chunk_size=1000) ``` ``` texts = text_splitter.split_text(state_of_the_union)print(texts[0]) ``` ``` Madam Speaker, Madam Vice President, our First Lady and Second Gentleman.Members of Congress and the Cabinet.Justices of the Supreme Court.My fellow Americans.Last year COVID-19 kept us apart.This year we are finally together again.Tonight, we meet as Democrats Republicans and Independents.But most importantly as Americans.With a duty to one another to the American people to the Constitution.And with an unwavering resolve that freedom will always triumph over tyranny.Six days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways.But he badly miscalculated.He thought he could roll into Ukraine and the world would roll over.Instead he met a wall of strength he never imagined.He met the Ukrainian people.From President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world.Groups of citizens blocking tanks with their bodies. ``` ## KoNLPY[​](#konlpy "Direct link to KoNLPY") > [KoNLPy: Korean NLP in Python](https://konlpy.org/en/latest/) is is a Python package for natural language processing (NLP) of the Korean language. Token splitting involves the segmentation of text into smaller, more manageable units called tokens. These tokens are often words, phrases, symbols, or other meaningful elements crucial for further processing and analysis. In languages like English, token splitting typically involves separating words by spaces and punctuation marks. The effectiveness of token splitting largely depends on the tokenizer’s understanding of the language structure, ensuring the generation of meaningful tokens. Since tokenizers designed for the English language are not equipped to understand the unique semantic structures of other languages, such as Korean, they cannot be effectively used for Korean language processing. ### Token splitting for Korean with KoNLPy’s Kkma Analyzer[​](#token-splitting-for-korean-with-konlpys-kkma-analyzer "Direct link to Token splitting for Korean with KoNLPy’s Kkma Analyzer") In case of Korean text, KoNLPY includes at morphological analyzer called `Kkma` (Korean Knowledge Morpheme Analyzer). `Kkma` provides detailed morphological analysis of Korean text. It breaks down sentences into words and words into their respective morphemes, identifying parts of speech for each token. It can segment a block of text into individual sentences, which is particularly useful for processing long texts. ### Usage Considerations[​](#usage-considerations "Direct link to Usage Considerations") While `Kkma` is renowned for its detailed analysis, it is important to note that this precision may impact processing speed. Thus, `Kkma` is best suited for applications where analytical depth is prioritized over rapid text processing. ``` # This is a long Korean document that we want to split up into its component sentences.with open("./your_korean_doc.txt") as f: korean_document = f.read() ``` ``` from langchain_text_splitters import KonlpyTextSplittertext_splitter = KonlpyTextSplitter() ``` ``` texts = text_splitter.split_text(korean_document)# The sentences are split with "\n\n" characters.print(texts[0]) ``` ``` 춘향전 옛날에 남원에 이 도령이라는 벼슬아치 아들이 있었다.그의 외모는 빛나는 달처럼 잘생겼고, 그의 학식과 기예는 남보다 뛰어났다.한편, 이 마을에는 춘향이라는 절세 가인이 살고 있었다.춘 향의 아름다움은 꽃과 같아 마을 사람들 로부터 많은 사랑을 받았다.어느 봄날, 도령은 친구들과 놀러 나갔다가 춘 향을 만 나 첫 눈에 반하고 말았다.두 사람은 서로 사랑하게 되었고, 이내 비밀스러운 사랑의 맹세를 나누었다.하지만 좋은 날들은 오래가지 않았다.도령의 아버지가 다른 곳으로 전근을 가게 되어 도령도 떠나 야만 했다.이별의 아픔 속에서도, 두 사람은 재회를 기약하며 서로를 믿고 기다리기로 했다.그러나 새로 부임한 관아의 사또가 춘 향의 아름다움에 욕심을 내 어 그녀에게 강요를 시작했다.춘 향 은 도령에 대한 자신의 사랑을 지키기 위해, 사또의 요구를 단호히 거절했다.이에 분노한 사또는 춘 향을 감옥에 가두고 혹독한 형벌을 내렸다.이야기는 이 도령이 고위 관직에 오른 후, 춘 향을 구해 내는 것으로 끝난다.두 사람은 오랜 시련 끝에 다시 만나게 되고, 그들의 사랑은 온 세상에 전해 지며 후세에까지 이어진다.- 춘향전 (The Tale of Chunhyang) ``` ## Hugging Face tokenizer[​](#hugging-face-tokenizer "Direct link to Hugging Face tokenizer") > [Hugging Face](https://huggingface.co/docs/tokenizers/index) has many tokenizers. We use Hugging Face tokenizer, the [GPT2TokenizerFast](https://huggingface.co/Ransaka/gpt2-tokenizer-fast) to count the text length in tokens. 1. How the text is split: by character passed in. 2. How the chunk size is measured: by number of tokens calculated by the `Hugging Face` tokenizer. ``` from transformers import GPT2TokenizerFasttokenizer = GPT2TokenizerFast.from_pretrained("gpt2") ``` ``` # This is a long document we can split up.with open("../../../state_of_the_union.txt") as f: state_of_the_union = f.read()from langchain_text_splitters import CharacterTextSplitter ``` ``` text_splitter = CharacterTextSplitter.from_huggingface_tokenizer( tokenizer, chunk_size=100, chunk_overlap=0)texts = text_splitter.split_text(state_of_the_union) ``` ``` Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. Last year COVID-19 kept us apart. This year we are finally together again. Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. With a duty to one another to the American people to the Constitution. ```

Split by tokens Language models have a token limit. You should not exceed the token limit. When you split your text into chunks it is therefore a good idea to count the number of tokens. There are many tokenizers. When you count tokens in your text you should use the same tokenizer as used in the language model. tiktoken​ tiktoken is a fast BPE tokenizer created by OpenAI. We can use it to estimate tokens used. It will probably be more accurate for the OpenAI models. How the text is split: by character passed in. How the chunk size is measured: by tiktoken tokenizer. %pip install --upgrade --quiet langchain-text-splitters tiktoken # This is a long document we can split up. with open("../../state_of_the_union.txt") as f: state_of_the_union = f.read() from langchain_text_splitters import CharacterTextSplitter The .from_tiktoken_encoder() method takes either encoding as an argument (e.g. cl100k_base), or the model_name (e.g. gpt-4). All additional arguments like chunk_size, chunk_overlap, and separators are used to instantiate CharacterTextSplitter: text_splitter = CharacterTextSplitter.from_tiktoken_encoder( encoding="cl100k_base", chunk_size=100, chunk_overlap=0 ) texts = text_splitter.split_text(state_of_the_union) Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. Last year COVID-19 kept us apart. This year we are finally together again. Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. With a duty to one another to the American people to the Constitution. Note that if we use CharacterTextSplitter.from_tiktoken_encoder, text is only split by CharacterTextSplitter and tiktoken tokenizer is used to merge splits. It means that split can be larger than chunk size measured by tiktoken tokenizer. We can use RecursiveCharacterTextSplitter.from_tiktoken_encoder to make sure splits are not larger than chunk size of tokens allowed by the language model, where each split will be recursively split if it has a larger size: from langchain_text_splitters import RecursiveCharacterTextSplitter text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder( model_name="gpt-4", chunk_size=100, chunk_overlap=0, ) We can also load a tiktoken splitter directly, which will ensure each split is smaller than chunk size. from langchain_text_splitters import TokenTextSplitter text_splitter = TokenTextSplitter(chunk_size=10, chunk_overlap=0) texts = text_splitter.split_text(state_of_the_union) print(texts[0]) Some written languages (e.g. Chinese and Japanese) have characters which encode to 2 or more tokens. Using the TokenTextSplitter directly can split the tokens for a character between two chunks causing malformed Unicode characters. Use RecursiveCharacterTextSplitter.from_tiktoken_encoder or CharacterTextSplitter.from_tiktoken_encoder to ensure chunks contain valid Unicode strings. spaCy​ spaCy is an open-source software library for advanced natural language processing, written in the programming languages Python and Cython. Another alternative to NLTK is to use spaCy tokenizer. How the text is split: by spaCy tokenizer. How the chunk size is measured: by number of characters. %pip install --upgrade --quiet spacy # This is a long document we can split up. with open("../../state_of_the_union.txt") as f: state_of_the_union = f.read() from langchain_text_splitters import SpacyTextSplitter text_splitter = SpacyTextSplitter(chunk_size=1000) texts = text_splitter.split_text(state_of_the_union) print(texts[0]) Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. Last year COVID-19 kept us apart. This year we are finally together again. Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. With a duty to one another to the American people to the Constitution. And with an unwavering resolve that freedom will always triumph over tyranny. Six days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. He thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. He met the Ukrainian people. From President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world. SentenceTransformers​ The SentenceTransformersTokenTextSplitter is a specialized text splitter for use with the sentence-transformer models. The default behaviour is to split the text into chunks that fit the token window of the sentence transformer model that you would like to use. from langchain_text_splitters import SentenceTransformersTokenTextSplitter splitter = SentenceTransformersTokenTextSplitter(chunk_overlap=0) text = "Lorem " count_start_and_stop_tokens = 2 text_token_count = splitter.count_tokens(text=text) - count_start_and_stop_tokens print(text_token_count) token_multiplier = splitter.maximum_tokens_per_chunk // text_token_count + 1 # `text_to_split` does not fit in a single chunk text_to_split = text * token_multiplier print(f"tokens in text to split: {splitter.count_tokens(text=text_to_split)}") tokens in text to split: 514 text_chunks = splitter.split_text(text=text_to_split) print(text_chunks[1]) NLTK​ The Natural Language Toolkit, or more commonly NLTK, is a suite of libraries and programs for symbolic and statistical natural language processing (NLP) for English written in the Python programming language. Rather than just splitting on “”, we can use NLTK to split based on NLTK tokenizers. How the text is split: by NLTK tokenizer. How the chunk size is measured: by number of characters. # This is a long document we can split up. with open("../../state_of_the_union.txt") as f: state_of_the_union = f.read() from langchain_text_splitters import NLTKTextSplitter text_splitter = NLTKTextSplitter(chunk_size=1000) texts = text_splitter.split_text(state_of_the_union) print(texts[0]) Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. Last year COVID-19 kept us apart. This year we are finally together again. Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. With a duty to one another to the American people to the Constitution. And with an unwavering resolve that freedom will always triumph over tyranny. Six days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. He thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. He met the Ukrainian people. From President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world. Groups of citizens blocking tanks with their bodies. KoNLPY​ KoNLPy: Korean NLP in Python is is a Python package for natural language processing (NLP) of the Korean language. Token splitting involves the segmentation of text into smaller, more manageable units called tokens. These tokens are often words, phrases, symbols, or other meaningful elements crucial for further processing and analysis. In languages like English, token splitting typically involves separating words by spaces and punctuation marks. The effectiveness of token splitting largely depends on the tokenizer’s understanding of the language structure, ensuring the generation of meaningful tokens. Since tokenizers designed for the English language are not equipped to understand the unique semantic structures of other languages, such as Korean, they cannot be effectively used for Korean language processing. Token splitting for Korean with KoNLPy’s Kkma Analyzer​ In case of Korean text, KoNLPY includes at morphological analyzer called Kkma (Korean Knowledge Morpheme Analyzer). Kkma provides detailed morphological analysis of Korean text. It breaks down sentences into words and words into their respective morphemes, identifying parts of speech for each token. It can segment a block of text into individual sentences, which is particularly useful for processing long texts. Usage Considerations​ While Kkma is renowned for its detailed analysis, it is important to note that this precision may impact processing speed. Thus, Kkma is best suited for applications where analytical depth is prioritized over rapid text processing. # This is a long Korean document that we want to split up into its component sentences. with open("./your_korean_doc.txt") as f: korean_document = f.read() from langchain_text_splitters import KonlpyTextSplitter text_splitter = KonlpyTextSplitter() texts = text_splitter.split_text(korean_document) # The sentences are split with "\n\n" characters. print(texts[0]) 춘향전 옛날에 남원에 이 도령이라는 벼슬아치 아들이 있었다. 그의 외모는 빛나는 달처럼 잘생겼고, 그의 학식과 기예는 남보다 뛰어났다. 한편, 이 마을에는 춘향이라는 절세 가인이 살고 있었다. 춘 향의 아름다움은 꽃과 같아 마을 사람들 로부터 많은 사랑을 받았다. 어느 봄날, 도령은 친구들과 놀러 나갔다가 춘 향을 만 나 첫 눈에 반하고 말았다. 두 사람은 서로 사랑하게 되었고, 이내 비밀스러운 사랑의 맹세를 나누었다. 하지만 좋은 날들은 오래가지 않았다. 도령의 아버지가 다른 곳으로 전근을 가게 되어 도령도 떠나 야만 했다. 이별의 아픔 속에서도, 두 사람은 재회를 기약하며 서로를 믿고 기다리기로 했다. 그러나 새로 부임한 관아의 사또가 춘 향의 아름다움에 욕심을 내 어 그녀에게 강요를 시작했다. 춘 향 은 도령에 대한 자신의 사랑을 지키기 위해, 사또의 요구를 단호히 거절했다. 이에 분노한 사또는 춘 향을 감옥에 가두고 혹독한 형벌을 내렸다. 이야기는 이 도령이 고위 관직에 오른 후, 춘 향을 구해 내는 것으로 끝난다. 두 사람은 오랜 시련 끝에 다시 만나게 되고, 그들의 사랑은 온 세상에 전해 지며 후세에까지 이어진다. - 춘향전 (The Tale of Chunhyang) Hugging Face tokenizer​ Hugging Face has many tokenizers. We use Hugging Face tokenizer, the GPT2TokenizerFast to count the text length in tokens. How the text is split: by character passed in. How the chunk size is measured: by number of tokens calculated by the Hugging Face tokenizer. from transformers import GPT2TokenizerFast tokenizer = GPT2TokenizerFast.from_pretrained("gpt2") # This is a long document we can split up. with open("../../../state_of_the_union.txt") as f: state_of_the_union = f.read() from langchain_text_splitters import CharacterTextSplitter text_splitter = CharacterTextSplitter.from_huggingface_tokenizer( tokenizer, chunk_size=100, chunk_overlap=0 ) texts = text_splitter.split_text(state_of_the_union) Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. Last year COVID-19 kept us apart. This year we are finally together again. Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. With a duty to one another to the American people to the Constitution.

https://python.langchain.com/docs/modules/memory/agent_with_memory_in_db/

This notebook goes over adding memory to an Agent where the memory uses an external message store. Before going through this notebook, please walkthrough the following notebooks, as this will build on top of both of them: * [Memory in LLMChain](https://python.langchain.com/docs/modules/memory/adding_memory/) * [Custom Agents](https://python.langchain.com/docs/modules/agents/how_to/custom_agent/) * [Memory in Agent](https://python.langchain.com/docs/modules/memory/agent_with_memory/) In order to add a memory with an external message store to an agent we are going to do the following steps: 1. We are going to create a `RedisChatMessageHistory` to connect to an external database to store the messages in. 2. We are going to create an `LLMChain` using that chat history as memory. 3. We are going to use that `LLMChain` to create a custom Agent. For the purposes of this exercise, we are going to create a simple custom Agent that has access to a search tool and utilizes the `ConversationBufferMemory` class. ``` import osfrom langchain import hubfrom langchain.agents import AgentExecutor, Toolfrom langchain_community.chat_message_histories import RedisChatMessageHistoryfrom langchain_community.utilities import SerpAPIWrapperfrom langchain_core.runnables.history import RunnableWithMessageHistoryfrom langchain_openai import OpenAI ``` ``` os.environ["GOOGLE_API_KEY"] = "GOOGLE_API_KEY"os.environ["GOOGLE_CSE_ID"] = "GOOGLE_CSE_ID"os.environ["OPENAI_API_KEY"] = "OPENAI_API_KEY"search = SerpAPIWrapper()tools = [ Tool( name="Search", func=search.run, description="useful for when you need to answer questions about current events", )] ``` Notice the usage of the `chat_history` variable in the `PromptTemplate`, which matches up with the dynamic key name in the `ConversationBufferMemory`. ``` prompt = hub.pull("hwchase17/react") ``` Now we can create the `RedisChatMessageHistory` backed by the database. ``` message_history = RedisChatMessageHistory( url="redis://127.0.0.1:6379/0", ttl=600, session_id="my-session") ``` We can now construct the `LLMChain`, with the Memory object, and then create the agent. ``` from langchain.agents import create_react_agentmodel = OpenAI()agent = create_react_agent(model, tools, prompt)agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) ``` ``` agent_with_chat_history = RunnableWithMessageHistory( agent_executor, # This is needed because in most real world scenarios, a session id is needed # It isn't really used here because we are using a simple in memory ChatMessageHistory lambda session_id: message_history, input_messages_key="input", history_messages_key="chat_history",)agent_with_chat_history.invoke( {"input": "How many people live in canada?"}, config={"configurable": {"session_id": "<foo>"}},) ``` ``` > Entering new AgentExecutor chain... I should use the Search tool to find the latest population data for Canada.Action: SearchAction Input: "population of canada"{'type': 'population_result', 'place': 'Canada', 'population': '38.93 million', 'year': '2022'}I now know the final answerFinal Answer: The final answer to the original input question is 38.93 million people live in Canada as of 2022.> Finished chain. ``` ``` {'input': 'How many people live in canada?', 'chat_history': [], 'output': 'The final answer to the original input question is 38.93 million people live in Canada as of 2022.'} ``` To test the memory of this agent, we can ask a followup question that relies on information in the previous exchange to be answered correctly. ``` agent_with_chat_history.invoke( {"input": "what is their national anthem called?"}, config={"configurable": {"session_id": "<foo>"}},) ``` ``` > Entering new AgentExecutor chain... There are many countries in the world with different national anthems, so I may need to specify which country's national anthem I am looking for.Action: SearchAction Input: "national anthem" + country name['"Liberté" ("Freedom") · "Esta É a Nossa Pátria Bem Amada" ("This Is Our Beloved Country") · "Dear Land of Guyana, of Rivers and Plains" · "La Dessalinienne" ("Song ...', 'National Anthem of Every Country ; Fiji, “Meda Dau Doka” (“God Bless Fiji”) ; Finland, “Maamme”. (“Our Land”) ; France, “La Marseillaise” (“The Marseillaise”).', 'List of national anthems ; Albania · Hymni i Flamurit · Algeria ; The Bahamas · March On, Bahamaland · Bahrain ; Cambodia · Nokoreach · Cameroon ; Madagascar · Ry ...', 'General information: Hatikvah (the Hope) is now firmly established as the Anthem of the State of Israel as well as the Jewish National Anthem. 1. While yet ...', 'National anthem · Afghanistan · Akrotiri · Albania · Algeria · American Samoa · Andorra · Angola · Anguilla.', 'Background > National anthems: Countries Compared ; DjiboutiDjibouti, Djibouti ; DominicaDominica, Isle of Beauty, Isle of Splendour ; Dominican RepublicDominican ...', "Today, the total number is massive, with all 193 UN countries having a national anthem. Former and non-UN countries' anthems add to the list. Due to space ...", '1. United States of America - The Star-Spangled Banner · 2. United Kingdom - God Save the Queen/King · 3. Canada - O Canada · 4. France - La ...', "Pedro I wrote the song that was used as the national anthem of Brazil from 1822 to 1831. The song is now recognized as the country's official patriotic song. 7."]I now know the final answerFinal Answer: The final answer cannot be determined without specifying which country's national anthem is being referred to.> Finished chain. ``` ``` {'input': 'what is their national anthem called?', 'chat_history': [HumanMessage(content='How many people live in canada?'), AIMessage(content='The final answer to the original input question is 38.93 million people live in Canada as of 2022.')], 'output': "The final answer cannot be determined without specifying which country's national anthem is being referred to."} ``` We can see that the agent remembered that the previous question was about Canada, and properly asked Google Search what the name of Canada’s national anthem was. For fun, let’s compare this to an agent that does NOT have memory. ``` agent = create_react_agent(model, tools, prompt)agent_executor__without_memory = AgentExecutor(agent=agent, tools=tools, verbose=True) ``` ``` agent_executor__without_memory.invoke({"input": "How many people live in canada?"}) ``` ``` > Entering new AgentExecutor chain... To find the number of people living in Canada, I should use a search engine to look for a reliable source.Action: SearchAction Input: "Population of Canada"{'type': 'population_result', 'place': 'Canada', 'population': '38.93 million', 'year': '2022'}38.93 million people live in Canada as of 2022.Final Answer: 38.93 million people live in Canada.> Finished chain. ``` ``` {'input': 'How many people live in canada?', 'output': '38.93 million people live in Canada.'} ``` ``` agent_executor__without_memory.invoke( {"input": "what is their national anthem called?"}) ``` ``` > Entering new AgentExecutor chain... I should always think about what to doAction: SearchAction Input: "national anthem of [country name]"['Most nation states have an anthem, defined as "a song, as of praise, devotion, or patriotism"; most anthems are either marches or hymns in style.', 'National Anthem of Every Country ; Fiji, “Meda Dau Doka” (“God Bless Fiji”) ; Finland, “Maamme”. (“Our Land”) ; France, “La Marseillaise” (“The Marseillaise”).', 'List of national anthems ; Albania · Hymni i Flamurit · Algeria ; The Bahamas · March On, Bahamaland · Bahrain ; Cambodia · Nokoreach · Cameroon ; Madagascar · Ry ...', 'General Information: First sung in 1844 with the title,. Sang till Norden (Song of the North). Its use as a. National Anthem dates from 1880-90. 1. Thou ancient ...', 'National anthem · Afghanistan · Akrotiri · Albania · Algeria · American Samoa · Andorra · Angola · Anguilla.', 'Background > National anthems: Countries Compared ; IndiaIndia, Jana Gana Mana ( Hail the ruler of all minds ) ; IndonesiaIndonesia, Indonesia Raya ( Great ...', '1. Afghanistan, "Milli Surood" (National Anthem) · 2. Armenia, "Mer Hayrenik" (Our Fatherland) · 3. Azerbaijan (a transcontinental country with ...', 'National Anthems of all the countries of the world ; Star Spangled Banner with Lyrics, Vocals, and Beautiful Photos. Musicplay ; Russia National ...', 'Himno Nacional del Perú, also known as Marcha Nacional del Perú or Somos libres, was selected as the national anthem of Peru in a public contest. Shortly after ...']I now know the final answerFinal Answer: It depends on the country, but their national anthem can be found by searching "national anthem of [country name]".> Finished chain. ``` ``` {'input': 'what is their national anthem called?', 'output': 'It depends on the country, but their national anthem can be found by searching "national anthem of [country name]".'} ```

This notebook goes over adding memory to an Agent where the memory uses an external message store. Before going through this notebook, please walkthrough the following notebooks, as this will build on top of both of them: Memory in LLMChain Custom Agents Memory in Agent In order to add a memory with an external message store to an agent we are going to do the following steps: We are going to create a RedisChatMessageHistory to connect to an external database to store the messages in. We are going to create an LLMChain using that chat history as memory. We are going to use that LLMChain to create a custom Agent. For the purposes of this exercise, we are going to create a simple custom Agent that has access to a search tool and utilizes the ConversationBufferMemory class. import os from langchain import hub from langchain.agents import AgentExecutor, Tool from langchain_community.chat_message_histories import RedisChatMessageHistory from langchain_community.utilities import SerpAPIWrapper from langchain_core.runnables.history import RunnableWithMessageHistory from langchain_openai import OpenAI os.environ["GOOGLE_API_KEY"] = "GOOGLE_API_KEY" os.environ["GOOGLE_CSE_ID"] = "GOOGLE_CSE_ID" os.environ["OPENAI_API_KEY"] = "OPENAI_API_KEY" search = SerpAPIWrapper() tools = [ Tool( name="Search", func=search.run, description="useful for when you need to answer questions about current events", ) ] Notice the usage of the chat_history variable in the PromptTemplate, which matches up with the dynamic key name in the ConversationBufferMemory. prompt = hub.pull("hwchase17/react") Now we can create the RedisChatMessageHistory backed by the database. message_history = RedisChatMessageHistory( url="redis://127.0.0.1:6379/0", ttl=600, session_id="my-session" ) We can now construct the LLMChain, with the Memory object, and then create the agent. from langchain.agents import create_react_agent model = OpenAI() agent = create_react_agent(model, tools, prompt) agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) agent_with_chat_history = RunnableWithMessageHistory( agent_executor, # This is needed because in most real world scenarios, a session id is needed # It isn't really used here because we are using a simple in memory ChatMessageHistory lambda session_id: message_history, input_messages_key="input", history_messages_key="chat_history", ) agent_with_chat_history.invoke( {"input": "How many people live in canada?"}, config={"configurable": {"session_id": "<foo>"}}, ) > Entering new AgentExecutor chain... I should use the Search tool to find the latest population data for Canada. Action: Search Action Input: "population of canada"{'type': 'population_result', 'place': 'Canada', 'population': '38.93 million', 'year': '2022'}I now know the final answer Final Answer: The final answer to the original input question is 38.93 million people live in Canada as of 2022. > Finished chain. {'input': 'How many people live in canada?', 'chat_history': [], 'output': 'The final answer to the original input question is 38.93 million people live in Canada as of 2022.'} To test the memory of this agent, we can ask a followup question that relies on information in the previous exchange to be answered correctly. agent_with_chat_history.invoke( {"input": "what is their national anthem called?"}, config={"configurable": {"session_id": "<foo>"}}, ) > Entering new AgentExecutor chain... There are many countries in the world with different national anthems, so I may need to specify which country's national anthem I am looking for. Action: Search Action Input: "national anthem" + country name['"Liberté" ("Freedom") · "Esta É a Nossa Pátria Bem Amada" ("This Is Our Beloved Country") · "Dear Land of Guyana, of Rivers and Plains" · "La Dessalinienne" ("Song ...', 'National Anthem of Every Country ; Fiji, “Meda Dau Doka” (“God Bless Fiji”) ; Finland, “Maamme”. (“Our Land”) ; France, “La Marseillaise” (“The Marseillaise”).', 'List of national anthems ; Albania · Hymni i Flamurit · Algeria ; The Bahamas · March On, Bahamaland · Bahrain ; Cambodia · Nokoreach · Cameroon ; Madagascar · Ry ...', 'General information: Hatikvah (the Hope) is now firmly established as the Anthem of the State of Israel as well as the Jewish National Anthem. 1. While yet ...', 'National anthem · Afghanistan · Akrotiri · Albania · Algeria · American Samoa · Andorra · Angola · Anguilla.', 'Background > National anthems: Countries Compared ; DjiboutiDjibouti, Djibouti ; DominicaDominica, Isle of Beauty, Isle of Splendour ; Dominican RepublicDominican ...', "Today, the total number is massive, with all 193 UN countries having a national anthem. Former and non-UN countries' anthems add to the list. Due to space ...", '1. United States of America - The Star-Spangled Banner · 2. United Kingdom - God Save the Queen/King · 3. Canada - O Canada · 4. France - La ...', "Pedro I wrote the song that was used as the national anthem of Brazil from 1822 to 1831. The song is now recognized as the country's official patriotic song. 7."]I now know the final answer Final Answer: The final answer cannot be determined without specifying which country's national anthem is being referred to. > Finished chain. {'input': 'what is their national anthem called?', 'chat_history': [HumanMessage(content='How many people live in canada?'), AIMessage(content='The final answer to the original input question is 38.93 million people live in Canada as of 2022.')], 'output': "The final answer cannot be determined without specifying which country's national anthem is being referred to."} We can see that the agent remembered that the previous question was about Canada, and properly asked Google Search what the name of Canada’s national anthem was. For fun, let’s compare this to an agent that does NOT have memory. agent = create_react_agent(model, tools, prompt) agent_executor__without_memory = AgentExecutor(agent=agent, tools=tools, verbose=True) agent_executor__without_memory.invoke({"input": "How many people live in canada?"}) > Entering new AgentExecutor chain... To find the number of people living in Canada, I should use a search engine to look for a reliable source. Action: Search Action Input: "Population of Canada"{'type': 'population_result', 'place': 'Canada', 'population': '38.93 million', 'year': '2022'}38.93 million people live in Canada as of 2022. Final Answer: 38.93 million people live in Canada. > Finished chain. {'input': 'How many people live in canada?', 'output': '38.93 million people live in Canada.'} agent_executor__without_memory.invoke( {"input": "what is their national anthem called?"} ) > Entering new AgentExecutor chain... I should always think about what to do Action: Search Action Input: "national anthem of [country name]"['Most nation states have an anthem, defined as "a song, as of praise, devotion, or patriotism"; most anthems are either marches or hymns in style.', 'National Anthem of Every Country ; Fiji, “Meda Dau Doka” (“God Bless Fiji”) ; Finland, “Maamme”. (“Our Land”) ; France, “La Marseillaise” (“The Marseillaise”).', 'List of national anthems ; Albania · Hymni i Flamurit · Algeria ; The Bahamas · March On, Bahamaland · Bahrain ; Cambodia · Nokoreach · Cameroon ; Madagascar · Ry ...', 'General Information: First sung in 1844 with the title,. Sang till Norden (Song of the North). Its use as a. National Anthem dates from 1880-90. 1. Thou ancient ...', 'National anthem · Afghanistan · Akrotiri · Albania · Algeria · American Samoa · Andorra · Angola · Anguilla.', 'Background > National anthems: Countries Compared ; IndiaIndia, Jana Gana Mana ( Hail the ruler of all minds ) ; IndonesiaIndonesia, Indonesia Raya ( Great ...', '1. Afghanistan, "Milli Surood" (National Anthem) · 2. Armenia, "Mer Hayrenik" (Our Fatherland) · 3. Azerbaijan (a transcontinental country with ...', 'National Anthems of all the countries of the world ; Star Spangled Banner with Lyrics, Vocals, and Beautiful Photos. Musicplay ; Russia National ...', 'Himno Nacional del Perú, also known as Marcha Nacional del Perú or Somos libres, was selected as the national anthem of Peru in a public contest. Shortly after ...']I now know the final answer Final Answer: It depends on the country, but their national anthem can be found by searching "national anthem of [country name]". > Finished chain. {'input': 'what is their national anthem called?', 'output': 'It depends on the country, but their national anthem can be found by searching "national anthem of [country name]".'}

https://python.langchain.com/docs/modules/data_connection/document_transformers/recursive_text_splitter/

## Recursively split by character This text splitter is the recommended one for generic text. It is parameterized by a list of characters. It tries to split on them in order until the chunks are small enough. The default list is `["\n\n", "\n", " ", ""]`. This has the effect of trying to keep all paragraphs (and then sentences, and then words) together as long as possible, as those would generically seem to be the strongest semantically related pieces of text. 1. How the text is split: by list of characters. 2. How the chunk size is measured: by number of characters. ``` %pip install -qU langchain-text-splitters ``` ``` # This is a long document we can split up.with open("../../state_of_the_union.txt") as f: state_of_the_union = f.read() ``` ``` from langchain_text_splitters import RecursiveCharacterTextSplitter ``` ``` text_splitter = RecursiveCharacterTextSplitter( # Set a really small chunk size, just to show. chunk_size=100, chunk_overlap=20, length_function=len, is_separator_regex=False,) ``` ``` texts = text_splitter.create_documents([state_of_the_union])print(texts[0])print(texts[1]) ``` ``` page_content='Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and'page_content='of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans.' ``` ``` text_splitter.split_text(state_of_the_union)[:2] ``` ``` ['Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and', 'of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans.'] ``` ## Splitting text from languages without word boundaries[​](#splitting-text-from-languages-without-word-boundaries "Direct link to Splitting text from languages without word boundaries") Some writing systems do not have [word boundaries](https://en.wikipedia.org/wiki/Category:Writing_systems_without_word_boundaries), for example Chinese, Japanese, and Thai. Splitting text with the default separator list of `["\n\n", "\n", " ", ""]` can cause words to be split between chunks. To keep words together, you can override the list of separators to include additional punctuation: * Add ASCII full-stop “`.`”, [Unicode fullwidth](https://en.wikipedia.org/wiki/Halfwidth_and_Fullwidth_Forms_(Unicode_block)) full stop “`．`” (used in Chinese text), and [ideographic full stop](https://en.wikipedia.org/wiki/CJK_Symbols_and_Punctuation) “`。`” (used in Japanese and Chinese) * Add [Zero-width space](https://en.wikipedia.org/wiki/Zero-width_space) used in Thai, Myanmar, Kmer, and Japanese. * Add ASCII comma “`,`”, Unicode fullwidth comma “`，`”, and Unicode ideographic comma “`、`” ``` text_splitter = RecursiveCharacterTextSplitter( separators=[ "\n\n", "\n", " ", ".", ",", "\u200B", # Zero-width space "\uff0c", # Fullwidth comma "\u3001", # Ideographic comma "\uff0e", # Fullwidth full stop "\u3002", # Ideographic full stop "", ], # Existing args) ```

Recursively split by character This text splitter is the recommended one for generic text. It is parameterized by a list of characters. It tries to split on them in order until the chunks are small enough. The default list is ["\n\n", "\n", " ", ""]. This has the effect of trying to keep all paragraphs (and then sentences, and then words) together as long as possible, as those would generically seem to be the strongest semantically related pieces of text. How the text is split: by list of characters. How the chunk size is measured: by number of characters. %pip install -qU langchain-text-splitters # This is a long document we can split up. with open("../../state_of_the_union.txt") as f: state_of_the_union = f.read() from langchain_text_splitters import RecursiveCharacterTextSplitter text_splitter = RecursiveCharacterTextSplitter( # Set a really small chunk size, just to show. chunk_size=100, chunk_overlap=20, length_function=len, is_separator_regex=False, ) texts = text_splitter.create_documents([state_of_the_union]) print(texts[0]) print(texts[1]) page_content='Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and' page_content='of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans.' text_splitter.split_text(state_of_the_union)[:2] ['Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and', 'of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans.'] Splitting text from languages without word boundaries​ Some writing systems do not have word boundaries, for example Chinese, Japanese, and Thai. Splitting text with the default separator list of ["\n\n", "\n", " ", ""] can cause words to be split between chunks. To keep words together, you can override the list of separators to include additional punctuation: Add ASCII full-stop “.”, Unicode fullwidth full stop “．” (used in Chinese text), and ideographic full stop “。” (used in Japanese and Chinese) Add Zero-width space used in Thai, Myanmar, Kmer, and Japanese. Add ASCII comma “,”, Unicode fullwidth comma “，”, and Unicode ideographic comma “、” text_splitter = RecursiveCharacterTextSplitter( separators=[ "\n\n", "\n", " ", ".", ",", "\u200B", # Zero-width space "\uff0c", # Fullwidth comma "\u3001", # Ideographic comma "\uff0e", # Fullwidth full stop "\u3002", # Ideographic full stop "", ], # Existing args )

https://python.langchain.com/docs/modules/data_connection/document_transformers/semantic-chunker/

## Semantic Chunking Splits the text based on semantic similarity. Taken from Greg Kamradt’s wonderful notebook: [5\_Levels\_Of\_Text\_Splitting](https://github.com/FullStackRetrieval-com/RetrievalTutorials/blob/main/tutorials/LevelsOfTextSplitting/5_Levels_Of_Text_Splitting.ipynb) All credit to him. At a high level, this splits into sentences, then groups into groups of 3 sentences, and then merges one that are similar in the embedding space. ## Install Dependencies[​](#install-dependencies "Direct link to Install Dependencies") ``` !pip install --quiet langchain_experimental langchain_openai ``` ## Load Example Data[​](#load-example-data "Direct link to Load Example Data") ``` # This is a long document we can split up.with open("../../state_of_the_union.txt") as f: state_of_the_union = f.read() ``` ## Create Text Splitter[​](#create-text-splitter "Direct link to Create Text Splitter") ``` from langchain_experimental.text_splitter import SemanticChunkerfrom langchain_openai.embeddings import OpenAIEmbeddings ``` ``` text_splitter = SemanticChunker(OpenAIEmbeddings()) ``` ## Split Text[​](#split-text "Direct link to Split Text") ``` docs = text_splitter.create_documents([state_of_the_union])print(docs[0].page_content) ``` ``` Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. Last year COVID-19 kept us apart. This year we are finally together again. Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. With a duty to one another to the American people to the Constitution. And with an unwavering resolve that freedom will always triumph over tyranny. Six days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. He thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. He met the Ukrainian people. From President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world. Groups of citizens blocking tanks with their bodies. Everyone from students to retirees teachers turned soldiers defending their homeland. In this struggle as President Zelenskyy said in his speech to the European Parliament “Light will win over darkness.” The Ukrainian Ambassador to the United States is here tonight. Let each of us here tonight in this Chamber send an unmistakable signal to Ukraine and to the world. Please rise if you are able and show that, Yes, we the United States of America stand with the Ukrainian people. Throughout our history we’ve learned this lesson when dictators do not pay a price for their aggression they cause more chaos. They keep moving. ``` ## Breakpoints[​](#breakpoints "Direct link to Breakpoints") This chunker works by determining when to “break” apart sentences. This is done by looking for differences in embeddings between any two sentences. When that difference is past some threshold, then they are split. There are a few ways to determine what that threshold is. ### Percentile[​](#percentile "Direct link to Percentile") The default way to split is based on percentile. In this method, all differences between sentences are calculated, and then any difference greater than the X percentile is split. ``` text_splitter = SemanticChunker( OpenAIEmbeddings(), breakpoint_threshold_type="percentile") ``` ``` docs = text_splitter.create_documents([state_of_the_union])print(docs[0].page_content) ``` ``` Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. Last year COVID-19 kept us apart. This year we are finally together again. Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. With a duty to one another to the American people to the Constitution. And with an unwavering resolve that freedom will always triumph over tyranny. Six days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. He thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. He met the Ukrainian people. From President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world. Groups of citizens blocking tanks with their bodies. Everyone from students to retirees teachers turned soldiers defending their homeland. In this struggle as President Zelenskyy said in his speech to the European Parliament “Light will win over darkness.” The Ukrainian Ambassador to the United States is here tonight. Let each of us here tonight in this Chamber send an unmistakable signal to Ukraine and to the world. Please rise if you are able and show that, Yes, we the United States of America stand with the Ukrainian people. Throughout our history we’ve learned this lesson when dictators do not pay a price for their aggression they cause more chaos. They keep moving. ``` ### Standard Deviation[​](#standard-deviation "Direct link to Standard Deviation") In this method, any difference greater than X standard deviations is split. ``` text_splitter = SemanticChunker( OpenAIEmbeddings(), breakpoint_threshold_type="standard_deviation") ``` ``` docs = text_splitter.create_documents([state_of_the_union])print(docs[0].page_content) ``` ``` Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. Last year COVID-19 kept us apart. This year we are finally together again. Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. With a duty to one another to the American people to the Constitution. And with an unwavering resolve that freedom will always triumph over tyranny. Six days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. He thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. He met the Ukrainian people. From President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world. Groups of citizens blocking tanks with their bodies. Everyone from students to retirees teachers turned soldiers defending their homeland. In this struggle as President Zelenskyy said in his speech to the European Parliament “Light will win over darkness.” The Ukrainian Ambassador to the United States is here tonight. Let each of us here tonight in this Chamber send an unmistakable signal to Ukraine and to the world. Please rise if you are able and show that, Yes, we the United States of America stand with the Ukrainian people. Throughout our history we’ve learned this lesson when dictators do not pay a price for their aggression they cause more chaos. They keep moving. And the costs and the threats to America and the world keep rising. That’s why the NATO Alliance was created to secure peace and stability in Europe after World War 2. The United States is a member along with 29 other nations. It matters. American diplomacy matters. American resolve matters. Putin’s latest attack on Ukraine was premeditated and unprovoked. He rejected repeated efforts at diplomacy. He thought the West and NATO wouldn’t respond. And he thought he could divide us at home. Putin was wrong. We were ready. Here is what we did. We prepared extensively and carefully. We spent months building a coalition of other freedom-loving nations from Europe and the Americas to Asia and Africa to confront Putin. I spent countless hours unifying our European allies. We shared with the world in advance what we knew Putin was planning and precisely how he would try to falsely justify his aggression. We countered Russia’s lies with truth. And now that he has acted the free world is holding him accountable. Along with twenty-seven members of the European Union including France, Germany, Italy, as well as countries like the United Kingdom, Canada, Japan, Korea, Australia, New Zealand, and many others, even Switzerland. We are inflicting pain on Russia and supporting the people of Ukraine. Putin is now isolated from the world more than ever. Together with our allies –we are right now enforcing powerful economic sanctions. We are cutting off Russia’s largest banks from the international financial system. Preventing Russia’s central bank from defending the Russian Ruble making Putin’s $630 Billion “war fund” worthless. We are choking off Russia’s access to technology that will sap its economic strength and weaken its military for years to come. Tonight I say to the Russian oligarchs and corrupt leaders who have bilked billions of dollars off this violent regime no more. The U.S. Department of Justice is assembling a dedicated task force to go after the crimes of Russian oligarchs. We are joining with our European allies to find and seize your yachts your luxury apartments your private jets. We are coming for your ill-begotten gains. And tonight I am announcing that we will join our allies in closing off American air space to all Russian flights – further isolating Russia – and adding an additional squeeze –on their economy. The Ruble has lost 30% of its value. The Russian stock market has lost 40% of its value and trading remains suspended. Russia’s economy is reeling and Putin alone is to blame. Together with our allies we are providing support to the Ukrainians in their fight for freedom. Military assistance. Economic assistance. Humanitarian assistance. We are giving more than $1 Billion in direct assistance to Ukraine. And we will continue to aid the Ukrainian people as they defend their country and to help ease their suffering. Let me be clear, our forces are not engaged and will not engage in conflict with Russian forces in Ukraine. Our forces are not going to Europe to fight in Ukraine, but to defend our NATO Allies – in the event that Putin decides to keep moving west. For that purpose we’ve mobilized American ground forces, air squadrons, and ship deployments to protect NATO countries including Poland, Romania, Latvia, Lithuania, and Estonia. As I have made crystal clear the United States and our Allies will defend every inch of territory of NATO countries with the full force of our collective power. And we remain clear-eyed. The Ukrainians are fighting back with pure courage. But the next few days weeks, months, will be hard on them. Putin has unleashed violence and chaos. But while he may make gains on the battlefield – he will pay a continuing high price over the long run. And a proud Ukrainian people, who have known 30 years of independence, have repeatedly shown that they will not tolerate anyone who tries to take their country backwards. To all Americans, I will be honest with you, as I’ve always promised. A Russian dictator, invading a foreign country, has costs around the world. And I’m taking robust action to make sure the pain of our sanctions is targeted at Russia’s economy. And I will use every tool at our disposal to protect American businesses and consumers. Tonight, I can announce that the United States has worked with 30 other countries to release 60 Million barrels of oil from reserves around the world. America will lead that effort, releasing 30 Million barrels from our own Strategic Petroleum Reserve. And we stand ready to do more if necessary, unified with our allies. These steps will help blunt gas prices here at home. And I know the news about what’s happening can seem alarming. ``` ### Interquartile[​](#interquartile "Direct link to Interquartile") In this method, the interquartile distance is used to split chunks. ``` text_splitter = SemanticChunker( OpenAIEmbeddings(), breakpoint_threshold_type="interquartile") ``` ``` docs = text_splitter.create_documents([state_of_the_union])print(docs[0].page_content) ``` ``` Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. Last year COVID-19 kept us apart. This year we are finally together again. Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. With a duty to one another to the American people to the Constitution. And with an unwavering resolve that freedom will always triumph over tyranny. Six days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. He thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. He met the Ukrainian people. From President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world. Groups of citizens blocking tanks with their bodies. Everyone from students to retirees teachers turned soldiers defending their homeland. In this struggle as President Zelenskyy said in his speech to the European Parliament “Light will win over darkness.” The Ukrainian Ambassador to the United States is here tonight. Let each of us here tonight in this Chamber send an unmistakable signal to Ukraine and to the world. Please rise if you are able and show that, Yes, we the United States of America stand with the Ukrainian people. Throughout our history we’ve learned this lesson when dictators do not pay a price for their aggression they cause more chaos. They keep moving. ```

Semantic Chunking Splits the text based on semantic similarity. Taken from Greg Kamradt’s wonderful notebook: 5_Levels_Of_Text_Splitting All credit to him. At a high level, this splits into sentences, then groups into groups of 3 sentences, and then merges one that are similar in the embedding space. Install Dependencies​ !pip install --quiet langchain_experimental langchain_openai Load Example Data​ # This is a long document we can split up. with open("../../state_of_the_union.txt") as f: state_of_the_union = f.read() Create Text Splitter​ from langchain_experimental.text_splitter import SemanticChunker from langchain_openai.embeddings import OpenAIEmbeddings text_splitter = SemanticChunker(OpenAIEmbeddings()) Split Text​ docs = text_splitter.create_documents([state_of_the_union]) print(docs[0].page_content) Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. Last year COVID-19 kept us apart. This year we are finally together again. Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. With a duty to one another to the American people to the Constitution. And with an unwavering resolve that freedom will always triumph over tyranny. Six days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. He thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. He met the Ukrainian people. From President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world. Groups of citizens blocking tanks with their bodies. Everyone from students to retirees teachers turned soldiers defending their homeland. In this struggle as President Zelenskyy said in his speech to the European Parliament “Light will win over darkness.” The Ukrainian Ambassador to the United States is here tonight. Let each of us here tonight in this Chamber send an unmistakable signal to Ukraine and to the world. Please rise if you are able and show that, Yes, we the United States of America stand with the Ukrainian people. Throughout our history we’ve learned this lesson when dictators do not pay a price for their aggression they cause more chaos. They keep moving. Breakpoints​ This chunker works by determining when to “break” apart sentences. This is done by looking for differences in embeddings between any two sentences. When that difference is past some threshold, then they are split. There are a few ways to determine what that threshold is. Percentile​ The default way to split is based on percentile. In this method, all differences between sentences are calculated, and then any difference greater than the X percentile is split. text_splitter = SemanticChunker( OpenAIEmbeddings(), breakpoint_threshold_type="percentile" ) docs = text_splitter.create_documents([state_of_the_union]) print(docs[0].page_content) Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. Last year COVID-19 kept us apart. This year we are finally together again. Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. With a duty to one another to the American people to the Constitution. And with an unwavering resolve that freedom will always triumph over tyranny. Six days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. He thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. He met the Ukrainian people. From President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world. Groups of citizens blocking tanks with their bodies. Everyone from students to retirees teachers turned soldiers defending their homeland. In this struggle as President Zelenskyy said in his speech to the European Parliament “Light will win over darkness.” The Ukrainian Ambassador to the United States is here tonight. Let each of us here tonight in this Chamber send an unmistakable signal to Ukraine and to the world. Please rise if you are able and show that, Yes, we the United States of America stand with the Ukrainian people. Throughout our history we’ve learned this lesson when dictators do not pay a price for their aggression they cause more chaos. They keep moving. Standard Deviation​ In this method, any difference greater than X standard deviations is split. text_splitter = SemanticChunker( OpenAIEmbeddings(), breakpoint_threshold_type="standard_deviation" ) docs = text_splitter.create_documents([state_of_the_union]) print(docs[0].page_content) Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. Last year COVID-19 kept us apart. This year we are finally together again. Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. With a duty to one another to the American people to the Constitution. And with an unwavering resolve that freedom will always triumph over tyranny. Six days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. He thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. He met the Ukrainian people. From President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world. Groups of citizens blocking tanks with their bodies. Everyone from students to retirees teachers turned soldiers defending their homeland. In this struggle as President Zelenskyy said in his speech to the European Parliament “Light will win over darkness.” The Ukrainian Ambassador to the United States is here tonight. Let each of us here tonight in this Chamber send an unmistakable signal to Ukraine and to the world. Please rise if you are able and show that, Yes, we the United States of America stand with the Ukrainian people. Throughout our history we’ve learned this lesson when dictators do not pay a price for their aggression they cause more chaos. They keep moving. And the costs and the threats to America and the world keep rising. That’s why the NATO Alliance was created to secure peace and stability in Europe after World War 2. The United States is a member along with 29 other nations. It matters. American diplomacy matters. American resolve matters. Putin’s latest attack on Ukraine was premeditated and unprovoked. He rejected repeated efforts at diplomacy. He thought the West and NATO wouldn’t respond. And he thought he could divide us at home. Putin was wrong. We were ready. Here is what we did. We prepared extensively and carefully. We spent months building a coalition of other freedom-loving nations from Europe and the Americas to Asia and Africa to confront Putin. I spent countless hours unifying our European allies. We shared with the world in advance what we knew Putin was planning and precisely how he would try to falsely justify his aggression. We countered Russia’s lies with truth. And now that he has acted the free world is holding him accountable. Along with twenty-seven members of the European Union including France, Germany, Italy, as well as countries like the United Kingdom, Canada, Japan, Korea, Australia, New Zealand, and many others, even Switzerland. We are inflicting pain on Russia and supporting the people of Ukraine. Putin is now isolated from the world more than ever. Together with our allies –we are right now enforcing powerful economic sanctions. We are cutting off Russia’s largest banks from the international financial system. Preventing Russia’s central bank from defending the Russian Ruble making Putin’s $630 Billion “war fund” worthless. We are choking off Russia’s access to technology that will sap its economic strength and weaken its military for years to come. Tonight I say to the Russian oligarchs and corrupt leaders who have bilked billions of dollars off this violent regime no more. The U.S. Department of Justice is assembling a dedicated task force to go after the crimes of Russian oligarchs. We are joining with our European allies to find and seize your yachts your luxury apartments your private jets. We are coming for your ill-begotten gains. And tonight I am announcing that we will join our allies in closing off American air space to all Russian flights – further isolating Russia – and adding an additional squeeze –on their economy. The Ruble has lost 30% of its value. The Russian stock market has lost 40% of its value and trading remains suspended. Russia’s economy is reeling and Putin alone is to blame. Together with our allies we are providing support to the Ukrainians in their fight for freedom. Military assistance. Economic assistance. Humanitarian assistance. We are giving more than $1 Billion in direct assistance to Ukraine. And we will continue to aid the Ukrainian people as they defend their country and to help ease their suffering. Let me be clear, our forces are not engaged and will not engage in conflict with Russian forces in Ukraine. Our forces are not going to Europe to fight in Ukraine, but to defend our NATO Allies – in the event that Putin decides to keep moving west. For that purpose we’ve mobilized American ground forces, air squadrons, and ship deployments to protect NATO countries including Poland, Romania, Latvia, Lithuania, and Estonia. As I have made crystal clear the United States and our Allies will defend every inch of territory of NATO countries with the full force of our collective power. And we remain clear-eyed. The Ukrainians are fighting back with pure courage. But the next few days weeks, months, will be hard on them. Putin has unleashed violence and chaos. But while he may make gains on the battlefield – he will pay a continuing high price over the long run. And a proud Ukrainian people, who have known 30 years of independence, have repeatedly shown that they will not tolerate anyone who tries to take their country backwards. To all Americans, I will be honest with you, as I’ve always promised. A Russian dictator, invading a foreign country, has costs around the world. And I’m taking robust action to make sure the pain of our sanctions is targeted at Russia’s economy. And I will use every tool at our disposal to protect American businesses and consumers. Tonight, I can announce that the United States has worked with 30 other countries to release 60 Million barrels of oil from reserves around the world. America will lead that effort, releasing 30 Million barrels from our own Strategic Petroleum Reserve. And we stand ready to do more if necessary, unified with our allies. These steps will help blunt gas prices here at home. And I know the news about what’s happening can seem alarming. Interquartile​ In this method, the interquartile distance is used to split chunks. text_splitter = SemanticChunker( OpenAIEmbeddings(), breakpoint_threshold_type="interquartile" ) docs = text_splitter.create_documents([state_of_the_union]) print(docs[0].page_content) Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans. Last year COVID-19 kept us apart. This year we are finally together again. Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. With a duty to one another to the American people to the Constitution. And with an unwavering resolve that freedom will always triumph over tyranny. Six days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. He thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. He met the Ukrainian people. From President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world. Groups of citizens blocking tanks with their bodies. Everyone from students to retirees teachers turned soldiers defending their homeland. In this struggle as President Zelenskyy said in his speech to the European Parliament “Light will win over darkness.” The Ukrainian Ambassador to the United States is here tonight. Let each of us here tonight in this Chamber send an unmistakable signal to Ukraine and to the world. Please rise if you are able and show that, Yes, we the United States of America stand with the Ukrainian people. Throughout our history we’ve learned this lesson when dictators do not pay a price for their aggression they cause more chaos. They keep moving.

https://python.langchain.com/docs/modules/memory/adding_memory/

## Memory in LLMChain This notebook goes over how to use the Memory class with an `LLMChain`. We will add the [ConversationBufferMemory](https://api.python.langchain.com/en/latest/memory/langchain.memory.buffer.ConversationBufferMemory.html#langchain.memory.buffer.ConversationBufferMemory) class, although this can be any memory class. ``` from langchain.chains import LLMChainfrom langchain.memory import ConversationBufferMemoryfrom langchain_core.prompts import PromptTemplatefrom langchain_openai import OpenAI ``` The most important step is setting up the prompt correctly. In the below prompt, we have two input keys: one for the actual input, another for the input from the Memory class. Importantly, we make sure the keys in the `PromptTemplate` and the `ConversationBufferMemory` match up (`chat_history`). ``` template = """You are a chatbot having a conversation with a human.{chat_history}Human: {human_input}Chatbot:"""prompt = PromptTemplate( input_variables=["chat_history", "human_input"], template=template)memory = ConversationBufferMemory(memory_key="chat_history") ``` ``` llm = OpenAI()llm_chain = LLMChain( llm=llm, prompt=prompt, verbose=True, memory=memory,) ``` ``` llm_chain.predict(human_input="Hi there my friend") ``` ``` > Entering new LLMChain chain...Prompt after formatting:You are a chatbot having a conversation with a human.Human: Hi there my friendChatbot:> Finished chain. ``` ``` ' Hi there! How can I help you today?' ``` ``` llm_chain.predict(human_input="Not too bad - how are you?") ``` ``` > Entering new LLMChain chain...Prompt after formatting:You are a chatbot having a conversation with a human.Human: Hi there my friendAI: Hi there! How can I help you today?Human: Not too bad - how are you?Chatbot:> Finished chain. ``` ``` " I'm doing great, thanks for asking! How are you doing?" ``` ## Adding Memory to a chat model-based `LLMChain`[​](#adding-memory-to-a-chat-model-based-llmchain "Direct link to adding-memory-to-a-chat-model-based-llmchain") The above works for completion-style `LLM`s, but if you are using a chat model, you will likely get better performance using structured chat messages. Below is an example. ``` from langchain_core.messages import SystemMessagefrom langchain_core.prompts import ( ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder,)from langchain_openai import ChatOpenAI ``` We will use the [ChatPromptTemplate](https://api.python.langchain.com/en/latest/prompts/langchain_core.prompts.chat.ChatPromptTemplate.html?highlight=chatprompttemplate) class to set up the chat prompt. The [from\_messages](https://api.python.langchain.com/en/latest/prompts/langchain_core.prompts.chat.ChatPromptTemplate.html#langchain_core.prompts.chat.ChatPromptTemplate.from_messages) method creates a `ChatPromptTemplate` from a list of messages (e.g., `SystemMessage`, `HumanMessage`, `AIMessage`, `ChatMessage`, etc.) or message templates, such as the [MessagesPlaceholder](https://api.python.langchain.com/en/latest/prompts/langchain_core.prompts.chat.MessagesPlaceholder.html#langchain_core.prompts.chat.MessagesPlaceholder) below. The configuration below makes it so the memory will be injected to the middle of the chat prompt, in the `chat_history` key, and the user’s inputs will be added in a human/user message to the end of the chat prompt. ``` prompt = ChatPromptTemplate.from_messages( [ SystemMessage( content="You are a chatbot having a conversation with a human." ), # The persistent system prompt MessagesPlaceholder( variable_name="chat_history" ), # Where the memory will be stored. HumanMessagePromptTemplate.from_template( "{human_input}" ), # Where the human input will injected ])memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True) ``` ``` llm = ChatOpenAI()chat_llm_chain = LLMChain( llm=llm, prompt=prompt, verbose=True, memory=memory,) ``` ``` chat_llm_chain.predict(human_input="Hi there my friend") ``` ``` > Entering new LLMChain chain...Prompt after formatting:System: You are a chatbot having a conversation with a human.Human: Hi there my friend> Finished chain. ``` ``` 'Hello! How can I assist you today, my friend?' ``` ``` chat_llm_chain.predict(human_input="Not too bad - how are you?") ``` ``` > Entering new LLMChain chain...Prompt after formatting:System: You are a chatbot having a conversation with a human.Human: Hi there my friendAI: Hello! How can I assist you today, my friend?Human: Not too bad - how are you?> Finished chain. ``` ``` "I'm an AI chatbot, so I don't have feelings, but I'm here to help and chat with you! Is there something specific you would like to talk about or any questions I can assist you with?" ```

Memory in LLMChain This notebook goes over how to use the Memory class with an LLMChain. We will add the ConversationBufferMemory class, although this can be any memory class. from langchain.chains import LLMChain from langchain.memory import ConversationBufferMemory from langchain_core.prompts import PromptTemplate from langchain_openai import OpenAI The most important step is setting up the prompt correctly. In the below prompt, we have two input keys: one for the actual input, another for the input from the Memory class. Importantly, we make sure the keys in the PromptTemplate and the ConversationBufferMemory match up (chat_history). template = """You are a chatbot having a conversation with a human. {chat_history} Human: {human_input} Chatbot:""" prompt = PromptTemplate( input_variables=["chat_history", "human_input"], template=template ) memory = ConversationBufferMemory(memory_key="chat_history") llm = OpenAI() llm_chain = LLMChain( llm=llm, prompt=prompt, verbose=True, memory=memory, ) llm_chain.predict(human_input="Hi there my friend") > Entering new LLMChain chain... Prompt after formatting: You are a chatbot having a conversation with a human. Human: Hi there my friend Chatbot: > Finished chain. ' Hi there! How can I help you today?' llm_chain.predict(human_input="Not too bad - how are you?") > Entering new LLMChain chain... Prompt after formatting: You are a chatbot having a conversation with a human. Human: Hi there my friend AI: Hi there! How can I help you today? Human: Not too bad - how are you? Chatbot: > Finished chain. " I'm doing great, thanks for asking! How are you doing?" Adding Memory to a chat model-based LLMChain​ The above works for completion-style LLMs, but if you are using a chat model, you will likely get better performance using structured chat messages. Below is an example. from langchain_core.messages import SystemMessage from langchain_core.prompts import ( ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder, ) from langchain_openai import ChatOpenAI We will use the ChatPromptTemplate class to set up the chat prompt. The from_messages method creates a ChatPromptTemplate from a list of messages (e.g., SystemMessage, HumanMessage, AIMessage, ChatMessage, etc.) or message templates, such as the MessagesPlaceholder below. The configuration below makes it so the memory will be injected to the middle of the chat prompt, in the chat_history key, and the user’s inputs will be added in a human/user message to the end of the chat prompt. prompt = ChatPromptTemplate.from_messages( [ SystemMessage( content="You are a chatbot having a conversation with a human." ), # The persistent system prompt MessagesPlaceholder( variable_name="chat_history" ), # Where the memory will be stored. HumanMessagePromptTemplate.from_template( "{human_input}" ), # Where the human input will injected ] ) memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True) llm = ChatOpenAI() chat_llm_chain = LLMChain( llm=llm, prompt=prompt, verbose=True, memory=memory, ) chat_llm_chain.predict(human_input="Hi there my friend") > Entering new LLMChain chain... Prompt after formatting: System: You are a chatbot having a conversation with a human. Human: Hi there my friend > Finished chain. 'Hello! How can I assist you today, my friend?' chat_llm_chain.predict(human_input="Not too bad - how are you?") > Entering new LLMChain chain... Prompt after formatting: System: You are a chatbot having a conversation with a human. Human: Hi there my friend AI: Hello! How can I assist you today, my friend? Human: Not too bad - how are you? > Finished chain. "I'm an AI chatbot, so I don't have feelings, but I'm here to help and chat with you! Is there something specific you would like to talk about or any questions I can assist you with?"

https://python.langchain.com/docs/modules/data_connection/indexing/

## Indexing Here, we will look at a basic indexing workflow using the LangChain indexing API. The indexing API lets you load and keep in sync documents from any source into a vector store. Specifically, it helps: * Avoid writing duplicated content into the vector store * Avoid re-writing unchanged content * Avoid re-computing embeddings over unchanged content All of which should save you time and money, as well as improve your vector search results. Crucially, the indexing API will work even with documents that have gone through several transformation steps (e.g., via text chunking) with respect to the original source documents. ## How it works[​](#how-it-works "Direct link to How it works") LangChain indexing makes use of a record manager (`RecordManager`) that keeps track of document writes into the vector store. When indexing content, hashes are computed for each document, and the following information is stored in the record manager: * the document hash (hash of both page content and metadata) * write time * the source id – each document should include information in its metadata to allow us to determine the ultimate source of this document ## Deletion modes[​](#deletion-modes "Direct link to Deletion modes") When indexing documents into a vector store, it’s possible that some existing documents in the vector store should be deleted. In certain situations you may want to remove any existing documents that are derived from the same sources as the new documents being indexed. In others you may want to delete all existing documents wholesale. The indexing API deletion modes let you pick the behavior you want: | Cleanup Mode | De-Duplicates Content | Parallelizable | Cleans Up Deleted Source Docs | Cleans Up Mutations of Source Docs and/or Derived Docs | Clean Up Timing | | --- | --- | --- | --- | --- | --- | | None | ✅ | ✅ | ❌ | ❌ | \- | | Incremental | ✅ | ✅ | ❌ | ✅ | Continuously | | Full | ✅ | ❌ | ✅ | ✅ | At end of indexing | `None` does not do any automatic clean up, allowing the user to manually do clean up of old content. `incremental` and `full` offer the following automated clean up: * If the content of the source document or derived documents has **changed**, both `incremental` or `full` modes will clean up (delete) previous versions of the content. * If the source document has been **deleted** (meaning it is not included in the documents currently being indexed), the `full` cleanup mode will delete it from the vector store correctly, but the `incremental` mode will not. When content is mutated (e.g., the source PDF file was revised) there will be a period of time during indexing when both the new and old versions may be returned to the user. This happens after the new content was written, but before the old version was deleted. * `incremental` indexing minimizes this period of time as it is able to do clean up continuously, as it writes. * `full` mode does the clean up after all batches have been written. ## Requirements[​](#requirements "Direct link to Requirements") 1. Do not use with a store that has been pre-populated with content independently of the indexing API, as the record manager will not know that records have been inserted previously. 2. Only works with LangChain `vectorstore`’s that support: * document addition by id (`add_documents` method with `ids` argument) * delete by id (`delete` method with `ids` argument) Compatible Vectorstores: `AnalyticDB`, `AstraDB`, `AwaDB`, `Bagel`, `Cassandra`, `Chroma`, `CouchbaseVectorStore`, `DashVector`, `DatabricksVectorSearch`, `DeepLake`, `Dingo`, `ElasticVectorSearch`, `ElasticsearchStore`, `FAISS`, `HanaDB`, `Milvus`, `MyScale`, `OpenSearchVectorSearch`, `PGVector`, `Pinecone`, `Qdrant`, `Redis`, `Rockset`, `ScaNN`, `SupabaseVectorStore`, `SurrealDBStore`, `TimescaleVector`, `Vald`, `VDMS`, `Vearch`, `VespaStore`, `Weaviate`, `ZepVectorStore`, `TencentVectorDB`, `OpenSearchVectorSearch`. ## Caution[​](#caution "Direct link to Caution") The record manager relies on a time-based mechanism to determine what content can be cleaned up (when using `full` or `incremental` cleanup modes). If two tasks run back-to-back, and the first task finishes before the clock time changes, then the second task may not be able to clean up content. This is unlikely to be an issue in actual settings for the following reasons: 1. The RecordManager uses higher resolution timestamps. 2. The data would need to change between the first and the second tasks runs, which becomes unlikely if the time interval between the tasks is small. 3. Indexing tasks typically take more than a few ms. ## Quickstart[​](#quickstart "Direct link to Quickstart") ``` from langchain.indexes import SQLRecordManager, indexfrom langchain_core.documents import Documentfrom langchain_elasticsearch import ElasticsearchStorefrom langchain_openai import OpenAIEmbeddings ``` Initialize a vector store and set up the embeddings: ``` collection_name = "test_index"embedding = OpenAIEmbeddings()vectorstore = ElasticsearchStore( es_url="http://localhost:9200", index_name="test_index", embedding=embedding) ``` Initialize a record manager with an appropriate namespace. **Suggestion:** Use a namespace that takes into account both the vector store and the collection name in the vector store; e.g., ‘redis/my\_docs’, ‘chromadb/my\_docs’ or ‘postgres/my\_docs’. ``` namespace = f"elasticsearch/{collection_name}"record_manager = SQLRecordManager( namespace, db_url="sqlite:///record_manager_cache.sql") ``` Create a schema before using the record manager. ``` record_manager.create_schema() ``` Let’s index some test documents: ``` doc1 = Document(page_content="kitty", metadata={"source": "kitty.txt"})doc2 = Document(page_content="doggy", metadata={"source": "doggy.txt"}) ``` Indexing into an empty vector store: ``` def _clear(): """Hacky helper method to clear content. See the `full` mode section to to understand why it works.""" index([], record_manager, vectorstore, cleanup="full", source_id_key="source") ``` ### `None` deletion mode[​](#none-deletion-mode "Direct link to none-deletion-mode") This mode does not do automatic clean up of old versions of content; however, it still takes care of content de-duplication. ``` index( [doc1, doc1, doc1, doc1, doc1], record_manager, vectorstore, cleanup=None, source_id_key="source",) ``` ``` {'num_added': 1, 'num_updated': 0, 'num_skipped': 0, 'num_deleted': 0} ``` ``` index([doc1, doc2], record_manager, vectorstore, cleanup=None, source_id_key="source") ``` ``` {'num_added': 2, 'num_updated': 0, 'num_skipped': 0, 'num_deleted': 0} ``` Second time around all content will be skipped: ``` index([doc1, doc2], record_manager, vectorstore, cleanup=None, source_id_key="source") ``` ``` {'num_added': 0, 'num_updated': 0, 'num_skipped': 2, 'num_deleted': 0} ``` ### `"incremental"` deletion mode[​](#incremental-deletion-mode "Direct link to incremental-deletion-mode") ``` index( [doc1, doc2], record_manager, vectorstore, cleanup="incremental", source_id_key="source",) ``` ``` {'num_added': 2, 'num_updated': 0, 'num_skipped': 0, 'num_deleted': 0} ``` Indexing again should result in both documents getting **skipped** – also skipping the embedding operation! ``` index( [doc1, doc2], record_manager, vectorstore, cleanup="incremental", source_id_key="source",) ``` ``` {'num_added': 0, 'num_updated': 0, 'num_skipped': 2, 'num_deleted': 0} ``` If we provide no documents with incremental indexing mode, nothing will change. ``` index([], record_manager, vectorstore, cleanup="incremental", source_id_key="source") ``` ``` {'num_added': 0, 'num_updated': 0, 'num_skipped': 0, 'num_deleted': 0} ``` If we mutate a document, the new version will be written and all old versions sharing the same source will be deleted. ``` changed_doc_2 = Document(page_content="puppy", metadata={"source": "doggy.txt"}) ``` ``` index( [changed_doc_2], record_manager, vectorstore, cleanup="incremental", source_id_key="source",) ``` ``` {'num_added': 1, 'num_updated': 0, 'num_skipped': 0, 'num_deleted': 1} ``` ### `"full"` deletion mode[​](#full-deletion-mode "Direct link to full-deletion-mode") In `full` mode the user should pass the `full` universe of content that should be indexed into the indexing function. Any documents that are not passed into the indexing function and are present in the vectorstore will be deleted! This behavior is useful to handle deletions of source documents. ``` index(all_docs, record_manager, vectorstore, cleanup="full", source_id_key="source") ``` ``` {'num_added': 2, 'num_updated': 0, 'num_skipped': 0, 'num_deleted': 0} ``` Say someone deleted the first doc: ``` [Document(page_content='doggy', metadata={'source': 'doggy.txt'})] ``` Using full mode will clean up the deleted content as well. ``` index(all_docs, record_manager, vectorstore, cleanup="full", source_id_key="source") ``` ``` {'num_added': 0, 'num_updated': 0, 'num_skipped': 1, 'num_deleted': 1} ``` ## Source[​](#source "Direct link to Source") The metadata attribute contains a field called `source`. This source should be pointing at the _ultimate_ provenance associated with the given document. For example, if these documents are representing chunks of some parent document, the `source` for both documents should be the same and reference the parent document. In general, `source` should always be specified. Only use a `None`, if you **never** intend to use `incremental` mode, and for some reason can’t specify the `source` field correctly. ``` from langchain_text_splitters import CharacterTextSplitter ``` ``` doc1 = Document( page_content="kitty kitty kitty kitty kitty", metadata={"source": "kitty.txt"})doc2 = Document(page_content="doggy doggy the doggy", metadata={"source": "doggy.txt"}) ``` ``` new_docs = CharacterTextSplitter( separator="t", keep_separator=True, chunk_size=12, chunk_overlap=2).split_documents([doc1, doc2])new_docs ``` ``` [Document(page_content='kitty kit', metadata={'source': 'kitty.txt'}), Document(page_content='tty kitty ki', metadata={'source': 'kitty.txt'}), Document(page_content='tty kitty', metadata={'source': 'kitty.txt'}), Document(page_content='doggy doggy', metadata={'source': 'doggy.txt'}), Document(page_content='the doggy', metadata={'source': 'doggy.txt'})] ``` ``` index( new_docs, record_manager, vectorstore, cleanup="incremental", source_id_key="source",) ``` ``` {'num_added': 5, 'num_updated': 0, 'num_skipped': 0, 'num_deleted': 0} ``` ``` changed_doggy_docs = [ Document(page_content="woof woof", metadata={"source": "doggy.txt"}), Document(page_content="woof woof woof", metadata={"source": "doggy.txt"}),] ``` This should delete the old versions of documents associated with `doggy.txt` source and replace them with the new versions. ``` index( changed_doggy_docs, record_manager, vectorstore, cleanup="incremental", source_id_key="source",) ``` ``` {'num_added': 2, 'num_updated': 0, 'num_skipped': 0, 'num_deleted': 2} ``` ``` vectorstore.similarity_search("dog", k=30) ``` ``` [Document(page_content='woof woof', metadata={'source': 'doggy.txt'}), Document(page_content='woof woof woof', metadata={'source': 'doggy.txt'}), Document(page_content='tty kitty', metadata={'source': 'kitty.txt'}), Document(page_content='tty kitty ki', metadata={'source': 'kitty.txt'}), Document(page_content='kitty kit', metadata={'source': 'kitty.txt'})] ``` ## Using with loaders[​](#using-with-loaders "Direct link to Using with loaders") Indexing can accept either an iterable of documents or else any loader. **Attention:** The loader **must** set source keys correctly. ``` from langchain_community.document_loaders.base import BaseLoaderclass MyCustomLoader(BaseLoader): def lazy_load(self): text_splitter = CharacterTextSplitter( separator="t", keep_separator=True, chunk_size=12, chunk_overlap=2 ) docs = [ Document(page_content="woof woof", metadata={"source": "doggy.txt"}), Document(page_content="woof woof woof", metadata={"source": "doggy.txt"}), ] yield from text_splitter.split_documents(docs) def load(self): return list(self.lazy_load()) ``` ``` loader = MyCustomLoader() ``` ``` [Document(page_content='woof woof', metadata={'source': 'doggy.txt'}), Document(page_content='woof woof woof', metadata={'source': 'doggy.txt'})] ``` ``` index(loader, record_manager, vectorstore, cleanup="full", source_id_key="source") ``` ``` {'num_added': 2, 'num_updated': 0, 'num_skipped': 0, 'num_deleted': 0} ``` ``` vectorstore.similarity_search("dog", k=30) ``` ``` [Document(page_content='woof woof', metadata={'source': 'doggy.txt'}), Document(page_content='woof woof woof', metadata={'source': 'doggy.txt'})] ```

Indexing Here, we will look at a basic indexing workflow using the LangChain indexing API. The indexing API lets you load and keep in sync documents from any source into a vector store. Specifically, it helps: Avoid writing duplicated content into the vector store Avoid re-writing unchanged content Avoid re-computing embeddings over unchanged content All of which should save you time and money, as well as improve your vector search results. Crucially, the indexing API will work even with documents that have gone through several transformation steps (e.g., via text chunking) with respect to the original source documents. How it works​ LangChain indexing makes use of a record manager (RecordManager) that keeps track of document writes into the vector store. When indexing content, hashes are computed for each document, and the following information is stored in the record manager: the document hash (hash of both page content and metadata) write time the source id – each document should include information in its metadata to allow us to determine the ultimate source of this document Deletion modes​ When indexing documents into a vector store, it’s possible that some existing documents in the vector store should be deleted. In certain situations you may want to remove any existing documents that are derived from the same sources as the new documents being indexed. In others you may want to delete all existing documents wholesale. The indexing API deletion modes let you pick the behavior you want: Cleanup ModeDe-Duplicates ContentParallelizableCleans Up Deleted Source DocsCleans Up Mutations of Source Docs and/or Derived DocsClean Up Timing None ✅ ✅ ❌ ❌ - Incremental ✅ ✅ ❌ ✅ Continuously Full ✅ ❌ ✅ ✅ At end of indexing None does not do any automatic clean up, allowing the user to manually do clean up of old content. incremental and full offer the following automated clean up: If the content of the source document or derived documents has changed, both incremental or full modes will clean up (delete) previous versions of the content. If the source document has been deleted (meaning it is not included in the documents currently being indexed), the full cleanup mode will delete it from the vector store correctly, but the incremental mode will not. When content is mutated (e.g., the source PDF file was revised) there will be a period of time during indexing when both the new and old versions may be returned to the user. This happens after the new content was written, but before the old version was deleted. incremental indexing minimizes this period of time as it is able to do clean up continuously, as it writes. full mode does the clean up after all batches have been written. Requirements​ Do not use with a store that has been pre-populated with content independently of the indexing API, as the record manager will not know that records have been inserted previously. Only works with LangChain vectorstore’s that support: document addition by id (add_documents method with ids argument) delete by id (delete method with ids argument) Compatible Vectorstores: AnalyticDB, AstraDB, AwaDB, Bagel, Cassandra, Chroma, CouchbaseVectorStore, DashVector, DatabricksVectorSearch, DeepLake, Dingo, ElasticVectorSearch, ElasticsearchStore, FAISS, HanaDB, Milvus, MyScale, OpenSearchVectorSearch, PGVector, Pinecone, Qdrant, Redis, Rockset, ScaNN, SupabaseVectorStore, SurrealDBStore, TimescaleVector, Vald, VDMS, Vearch, VespaStore, Weaviate, ZepVectorStore, TencentVectorDB, OpenSearchVectorSearch. Caution​ The record manager relies on a time-based mechanism to determine what content can be cleaned up (when using full or incremental cleanup modes). If two tasks run back-to-back, and the first task finishes before the clock time changes, then the second task may not be able to clean up content. This is unlikely to be an issue in actual settings for the following reasons: The RecordManager uses higher resolution timestamps. The data would need to change between the first and the second tasks runs, which becomes unlikely if the time interval between the tasks is small. Indexing tasks typically take more than a few ms. Quickstart​ from langchain.indexes import SQLRecordManager, index from langchain_core.documents import Document from langchain_elasticsearch import ElasticsearchStore from langchain_openai import OpenAIEmbeddings Initialize a vector store and set up the embeddings: collection_name = "test_index" embedding = OpenAIEmbeddings() vectorstore = ElasticsearchStore( es_url="http://localhost:9200", index_name="test_index", embedding=embedding ) Initialize a record manager with an appropriate namespace. Suggestion: Use a namespace that takes into account both the vector store and the collection name in the vector store; e.g., ‘redis/my_docs’, ‘chromadb/my_docs’ or ‘postgres/my_docs’. namespace = f"elasticsearch/{collection_name}" record_manager = SQLRecordManager( namespace, db_url="sqlite:///record_manager_cache.sql" ) Create a schema before using the record manager. record_manager.create_schema() Let’s index some test documents: doc1 = Document(page_content="kitty", metadata={"source": "kitty.txt"}) doc2 = Document(page_content="doggy", metadata={"source": "doggy.txt"}) Indexing into an empty vector store: def _clear(): """Hacky helper method to clear content. See the `full` mode section to to understand why it works.""" index([], record_manager, vectorstore, cleanup="full", source_id_key="source") None deletion mode​ This mode does not do automatic clean up of old versions of content; however, it still takes care of content de-duplication. index( [doc1, doc1, doc1, doc1, doc1], record_manager, vectorstore, cleanup=None, source_id_key="source", ) {'num_added': 1, 'num_updated': 0, 'num_skipped': 0, 'num_deleted': 0} index([doc1, doc2], record_manager, vectorstore, cleanup=None, source_id_key="source") {'num_added': 2, 'num_updated': 0, 'num_skipped': 0, 'num_deleted': 0} Second time around all content will be skipped: index([doc1, doc2], record_manager, vectorstore, cleanup=None, source_id_key="source") {'num_added': 0, 'num_updated': 0, 'num_skipped': 2, 'num_deleted': 0} "incremental" deletion mode​ index( [doc1, doc2], record_manager, vectorstore, cleanup="incremental", source_id_key="source", ) {'num_added': 2, 'num_updated': 0, 'num_skipped': 0, 'num_deleted': 0} Indexing again should result in both documents getting skipped – also skipping the embedding operation! index( [doc1, doc2], record_manager, vectorstore, cleanup="incremental", source_id_key="source", ) {'num_added': 0, 'num_updated': 0, 'num_skipped': 2, 'num_deleted': 0} If we provide no documents with incremental indexing mode, nothing will change. index([], record_manager, vectorstore, cleanup="incremental", source_id_key="source") {'num_added': 0, 'num_updated': 0, 'num_skipped': 0, 'num_deleted': 0} If we mutate a document, the new version will be written and all old versions sharing the same source will be deleted. changed_doc_2 = Document(page_content="puppy", metadata={"source": "doggy.txt"}) index( [changed_doc_2], record_manager, vectorstore, cleanup="incremental", source_id_key="source", ) {'num_added': 1, 'num_updated': 0, 'num_skipped': 0, 'num_deleted': 1} "full" deletion mode​ In full mode the user should pass the full universe of content that should be indexed into the indexing function. Any documents that are not passed into the indexing function and are present in the vectorstore will be deleted! This behavior is useful to handle deletions of source documents. index(all_docs, record_manager, vectorstore, cleanup="full", source_id_key="source") {'num_added': 2, 'num_updated': 0, 'num_skipped': 0, 'num_deleted': 0} Say someone deleted the first doc: [Document(page_content='doggy', metadata={'source': 'doggy.txt'})] Using full mode will clean up the deleted content as well. index(all_docs, record_manager, vectorstore, cleanup="full", source_id_key="source") {'num_added': 0, 'num_updated': 0, 'num_skipped': 1, 'num_deleted': 1} Source​ The metadata attribute contains a field called source. This source should be pointing at the ultimate provenance associated with the given document. For example, if these documents are representing chunks of some parent document, the source for both documents should be the same and reference the parent document. In general, source should always be specified. Only use a None, if you never intend to use incremental mode, and for some reason can’t specify the source field correctly. from langchain_text_splitters import CharacterTextSplitter doc1 = Document( page_content="kitty kitty kitty kitty kitty", metadata={"source": "kitty.txt"} ) doc2 = Document(page_content="doggy doggy the doggy", metadata={"source": "doggy.txt"}) new_docs = CharacterTextSplitter( separator="t", keep_separator=True, chunk_size=12, chunk_overlap=2 ).split_documents([doc1, doc2]) new_docs [Document(page_content='kitty kit', metadata={'source': 'kitty.txt'}), Document(page_content='tty kitty ki', metadata={'source': 'kitty.txt'}), Document(page_content='tty kitty', metadata={'source': 'kitty.txt'}), Document(page_content='doggy doggy', metadata={'source': 'doggy.txt'}), Document(page_content='the doggy', metadata={'source': 'doggy.txt'})] index( new_docs, record_manager, vectorstore, cleanup="incremental", source_id_key="source", ) {'num_added': 5, 'num_updated': 0, 'num_skipped': 0, 'num_deleted': 0} changed_doggy_docs = [ Document(page_content="woof woof", metadata={"source": "doggy.txt"}), Document(page_content="woof woof woof", metadata={"source": "doggy.txt"}), ] This should delete the old versions of documents associated with doggy.txt source and replace them with the new versions. index( changed_doggy_docs, record_manager, vectorstore, cleanup="incremental", source_id_key="source", ) {'num_added': 2, 'num_updated': 0, 'num_skipped': 0, 'num_deleted': 2} vectorstore.similarity_search("dog", k=30) [Document(page_content='woof woof', metadata={'source': 'doggy.txt'}), Document(page_content='woof woof woof', metadata={'source': 'doggy.txt'}), Document(page_content='tty kitty', metadata={'source': 'kitty.txt'}), Document(page_content='tty kitty ki', metadata={'source': 'kitty.txt'}), Document(page_content='kitty kit', metadata={'source': 'kitty.txt'})] Using with loaders​ Indexing can accept either an iterable of documents or else any loader. Attention: The loader must set source keys correctly. from langchain_community.document_loaders.base import BaseLoader class MyCustomLoader(BaseLoader): def lazy_load(self): text_splitter = CharacterTextSplitter( separator="t", keep_separator=True, chunk_size=12, chunk_overlap=2 ) docs = [ Document(page_content="woof woof", metadata={"source": "doggy.txt"}), Document(page_content="woof woof woof", metadata={"source": "doggy.txt"}), ] yield from text_splitter.split_documents(docs) def load(self): return list(self.lazy_load()) loader = MyCustomLoader() [Document(page_content='woof woof', metadata={'source': 'doggy.txt'}), Document(page_content='woof woof woof', metadata={'source': 'doggy.txt'})] index(loader, record_manager, vectorstore, cleanup="full", source_id_key="source") {'num_added': 2, 'num_updated': 0, 'num_skipped': 0, 'num_deleted': 0} vectorstore.similarity_search("dog", k=30) [Document(page_content='woof woof', metadata={'source': 'doggy.txt'}), Document(page_content='woof woof woof', metadata={'source': 'doggy.txt'})]

https://python.langchain.com/docs/modules/memory/agent_with_memory/

## Memory in Agent This notebook goes over adding memory to an Agent. Before going through this notebook, please walkthrough the following notebooks, as this will build on top of both of them: * [Memory in LLMChain](https://python.langchain.com/docs/modules/memory/adding_memory/) * [Custom Agents](https://python.langchain.com/docs/modules/agents/how_to/custom_agent/) In order to add a memory to an agent we are going to perform the following steps: 1. We are going to create an `LLMChain` with memory. 2. We are going to use that `LLMChain` to create a custom Agent. For the purposes of this exercise, we are going to create a simple custom Agent that has access to a search tool and utilizes the `ConversationBufferMemory` class. ``` import osfrom langchain.agents import Toolfrom langchain_community.utilities import GoogleSearchAPIWrapper ``` ``` os.environ["GOOGLE_API_KEY"] = "GOOGLE_API_KEY"os.environ["GOOGLE_CSE_ID"] = "GOOGLE_CSE_ID"os.environ["OPENAI_API_KEY"] = "OPENAI_API_KEY"search = GoogleSearchAPIWrapper()tools = [ Tool( name="Search", func=search.run, description="useful for when you need to answer questions about current events", )] ``` Notice the usage of the `chat_history` variable in the `PromptTemplate`, which matches up with the dynamic key name in the `ConversationBufferMemory`. ``` from langchain import hubfrom langchain.agents import AgentExecutor, create_react_agentfrom langchain.memory import ChatMessageHistoryprompt = hub.pull("hwchase17/react")memory = ChatMessageHistory(session_id="test-session") ``` ``` from langchain_core.runnables.history import RunnableWithMessageHistoryfrom langchain_openai import OpenAIllm = OpenAI(temperature=0)agent = create_react_agent(llm, tools, prompt)agent_executor = AgentExecutor(agent=agent, tools=tools)agent_with_chat_history = RunnableWithMessageHistory( agent_executor, # This is needed because in most real world scenarios, a session id is needed # It isn't really used here because we are using a simple in memory ChatMessageHistory lambda session_id: memory, input_messages_key="input", history_messages_key="chat_history",) ``` ``` agent_with_chat_history.invoke( {"input": "How many people live in canada?"}, config={"configurable": {"session_id": "<foo>"}},) ``` ``` > Entering new AgentExecutor chain... I should use the Search tool to find the most recent population data for Canada.Action: SearchAction Input: "population of Canada"{'type': 'population_result', 'place': 'Canada', 'population': '38.93 million', 'year': '2022'}38.93 million people live in Canada as of 2022.Final Answer: 38.93 million> Finished chain. ``` ``` {'input': 'How many people live in canada?', 'chat_history': [], 'output': '38.93 million'} ``` To test the memory of this agent, we can ask a followup question that relies on information in the previous exchange to be answered correctly. ``` agent_with_chat_history.invoke( {"input": "what is their national anthem called?"}, config={"configurable": {"session_id": "<foo>"}},) ``` ``` > Entering new AgentExecutor chain... I should search for the country's name and "national anthem"Action: SearchAction Input: "country name" national anthem['"Liberté" ("Freedom") · "Esta É a Nossa Pátria Bem Amada" ("This Is Our Beloved Country") · "Dear Land of Guyana, of Rivers and Plains" · "La Dessalinienne" ("Song ...', 'National Anthem of Every Country ; Fiji, “Meda Dau Doka” (“God Bless Fiji”) ; Finland, “Maamme”. (“Our Land”) ; France, “La Marseillaise” (“The Marseillaise”).', 'List of national anthems ; Albania · Hymni i Flamurit · Algeria ; The Bahamas · March On, Bahamaland · Bahrain ; Cambodia · Nokoreach · Cameroon ; Madagascar · Ry ...', 'General information: Hatikvah (the Hope) is now firmly established as the Anthem of the State of Israel as well as the Jewish National Anthem. 1. While yet ...', 'National anthem · Afghanistan · Akrotiri · Albania · Algeria · American Samoa · Andorra · Angola · Anguilla.', 'Background > National anthems: Countries Compared ; IndonesiaIndonesia, Indonesia Raya ( Great Indonesia ) ; IranIran, Soroud-e Melli-e Jomhouri-e Eslami-e Iran ( ...', '1. Afghanistan, "Milli Surood" (National Anthem) · 2. Armenia, "Mer Hayrenik" (Our Fatherland) · 3. Azerbaijan (a transcontinental country with ...', 'National Anthems of all the countries of the world ; Star Spangled Banner with Lyrics, Vocals, and Beautiful Photos. Musicplay ; Russia National ...', "The countries with the ten newest anthem additions adopted them between 2006 to as recently as 2021. Let's take a look: ... Afghanistan's “Dā də bātorāno kor” (“ ..."]I now know the final answerFinal Answer: The national anthem of a country can be found by searching for the country's name and "national anthem".> Finished chain. ``` ``` {'input': 'what is their national anthem called?', 'chat_history': [HumanMessage(content='How many people live in canada?'), AIMessage(content='38.93 million')], 'output': 'The national anthem of a country can be found by searching for the country\'s name and "national anthem".'} ``` We can see that the agent remembered that the previous question was about Canada, and properly asked Google Search what the name of Canada’s national anthem was. For fun, let’s compare this to an agent that does NOT have memory. ``` agent = create_react_agent(llm, tools, prompt)agent_executor_without_memory = AgentExecutor(agent=agent, tools=tools) ``` ``` agent_executor_without_memory.invoke({"input": "How many people live in canada?"}) ``` ``` > Entering new AgentExecutor chain... I should use the Search tool to find the most recent population data for Canada.Action: SearchAction Input: "population of Canada"{'type': 'population_result', 'place': 'Canada', 'population': '38.93 million', 'year': '2022'}I should check the source of the data to ensure it is reliable.Action: SearchAction Input: "population of Canada source"The 2021 Canadian census enumerated a total population of 36,991,981, an increase of around 5.2 percent over the 2016 figure. It is estimated that Canada's population surpassed 40 million in 2023 and 41 million in 2024. I now know the final answer.Final Answer: The estimated population of Canada in 2022 is 38.93 million.> Finished chain. ``` ``` {'input': 'How many people live in canada?', 'output': 'The estimated population of Canada in 2022 is 38.93 million.'} ``` ``` agent_executor_without_memory.invoke({"input": "what is their national anthem called?"}) ``` ``` > Entering new AgentExecutor chain... I should search for the country's name and "national anthem"Action: SearchAction Input: "country name" national anthem['"Liberté" ("Freedom") · "Esta É a Nossa Pátria Bem Amada" ("This Is Our Beloved Country") · "Dear Land of Guyana, of Rivers and Plains" · "La Dessalinienne" ("Song ...', 'National Anthem of Every Country ; Fiji, “Meda Dau Doka” (“God Bless Fiji”) ; Finland, “Maamme”. (“Our Land”) ; France, “La Marseillaise” (“The Marseillaise”).', 'List of national anthems ; Albania · Hymni i Flamurit · Algeria ; The Bahamas · March On, Bahamaland · Bahrain ; Cambodia · Nokoreach · Cameroon ; Madagascar · Ry ...', 'General information: Hatikvah (the Hope) is now firmly established as the Anthem of the State of Israel as well as the Jewish National Anthem. 1. While yet ...', 'National anthem · Afghanistan · Akrotiri · Albania · Algeria · American Samoa · Andorra · Angola · Anguilla.', 'Background > National anthems: Countries Compared ; IndonesiaIndonesia, Indonesia Raya ( Great Indonesia ) ; IranIran, Soroud-e Melli-e Jomhouri-e Eslami-e Iran ( ...', '1. Afghanistan, "Milli Surood" (National Anthem) · 2. Armenia, "Mer Hayrenik" (Our Fatherland) · 3. Azerbaijan (a transcontinental country with ...', 'National Anthems of all the countries of the world ; Star Spangled Banner with Lyrics, Vocals, and Beautiful Photos. Musicplay ; Russia National ...', "The countries with the ten newest anthem additions adopted them between 2006 to as recently as 2021. Let's take a look: ... Afghanistan's “Dā də bātorāno kor” (“ ..."]I now know the final answerFinal Answer: The national anthem of Afghanistan is called "Milli Surood".> Finished chain. ``` ``` {'input': 'what is their national anthem called?', 'output': 'The national anthem of Afghanistan is called "Milli Surood".'} ```

Memory in Agent This notebook goes over adding memory to an Agent. Before going through this notebook, please walkthrough the following notebooks, as this will build on top of both of them: Memory in LLMChain Custom Agents In order to add a memory to an agent we are going to perform the following steps: We are going to create an LLMChain with memory. We are going to use that LLMChain to create a custom Agent. For the purposes of this exercise, we are going to create a simple custom Agent that has access to a search tool and utilizes the ConversationBufferMemory class. import os from langchain.agents import Tool from langchain_community.utilities import GoogleSearchAPIWrapper os.environ["GOOGLE_API_KEY"] = "GOOGLE_API_KEY" os.environ["GOOGLE_CSE_ID"] = "GOOGLE_CSE_ID" os.environ["OPENAI_API_KEY"] = "OPENAI_API_KEY" search = GoogleSearchAPIWrapper() tools = [ Tool( name="Search", func=search.run, description="useful for when you need to answer questions about current events", ) ] Notice the usage of the chat_history variable in the PromptTemplate, which matches up with the dynamic key name in the ConversationBufferMemory. from langchain import hub from langchain.agents import AgentExecutor, create_react_agent from langchain.memory import ChatMessageHistory prompt = hub.pull("hwchase17/react") memory = ChatMessageHistory(session_id="test-session") from langchain_core.runnables.history import RunnableWithMessageHistory from langchain_openai import OpenAI llm = OpenAI(temperature=0) agent = create_react_agent(llm, tools, prompt) agent_executor = AgentExecutor(agent=agent, tools=tools) agent_with_chat_history = RunnableWithMessageHistory( agent_executor, # This is needed because in most real world scenarios, a session id is needed # It isn't really used here because we are using a simple in memory ChatMessageHistory lambda session_id: memory, input_messages_key="input", history_messages_key="chat_history", ) agent_with_chat_history.invoke( {"input": "How many people live in canada?"}, config={"configurable": {"session_id": "<foo>"}}, ) > Entering new AgentExecutor chain... I should use the Search tool to find the most recent population data for Canada. Action: Search Action Input: "population of Canada"{'type': 'population_result', 'place': 'Canada', 'population': '38.93 million', 'year': '2022'}38.93 million people live in Canada as of 2022. Final Answer: 38.93 million > Finished chain. {'input': 'How many people live in canada?', 'chat_history': [], 'output': '38.93 million'} To test the memory of this agent, we can ask a followup question that relies on information in the previous exchange to be answered correctly. agent_with_chat_history.invoke( {"input": "what is their national anthem called?"}, config={"configurable": {"session_id": "<foo>"}}, ) > Entering new AgentExecutor chain... I should search for the country's name and "national anthem" Action: Search Action Input: "country name" national anthem['"Liberté" ("Freedom") · "Esta É a Nossa Pátria Bem Amada" ("This Is Our Beloved Country") · "Dear Land of Guyana, of Rivers and Plains" · "La Dessalinienne" ("Song ...', 'National Anthem of Every Country ; Fiji, “Meda Dau Doka” (“God Bless Fiji”) ; Finland, “Maamme”. (“Our Land”) ; France, “La Marseillaise” (“The Marseillaise”).', 'List of national anthems ; Albania · Hymni i Flamurit · Algeria ; The Bahamas · March On, Bahamaland · Bahrain ; Cambodia · Nokoreach · Cameroon ; Madagascar · Ry ...', 'General information: Hatikvah (the Hope) is now firmly established as the Anthem of the State of Israel as well as the Jewish National Anthem. 1. While yet ...', 'National anthem · Afghanistan · Akrotiri · Albania · Algeria · American Samoa · Andorra · Angola · Anguilla.', 'Background > National anthems: Countries Compared ; IndonesiaIndonesia, Indonesia Raya ( Great Indonesia ) ; IranIran, Soroud-e Melli-e Jomhouri-e Eslami-e Iran ( ...', '1. Afghanistan, "Milli Surood" (National Anthem) · 2. Armenia, "Mer Hayrenik" (Our Fatherland) · 3. Azerbaijan (a transcontinental country with ...', 'National Anthems of all the countries of the world ; Star Spangled Banner with Lyrics, Vocals, and Beautiful Photos. Musicplay ; Russia National ...', "The countries with the ten newest anthem additions adopted them between 2006 to as recently as 2021. Let's take a look: ... Afghanistan's “Dā də bātorāno kor” (“ ..."]I now know the final answer Final Answer: The national anthem of a country can be found by searching for the country's name and "national anthem". > Finished chain. {'input': 'what is their national anthem called?', 'chat_history': [HumanMessage(content='How many people live in canada?'), AIMessage(content='38.93 million')], 'output': 'The national anthem of a country can be found by searching for the country\'s name and "national anthem".'} We can see that the agent remembered that the previous question was about Canada, and properly asked Google Search what the name of Canada’s national anthem was. For fun, let’s compare this to an agent that does NOT have memory. agent = create_react_agent(llm, tools, prompt) agent_executor_without_memory = AgentExecutor(agent=agent, tools=tools) agent_executor_without_memory.invoke({"input": "How many people live in canada?"}) > Entering new AgentExecutor chain... I should use the Search tool to find the most recent population data for Canada. Action: Search Action Input: "population of Canada"{'type': 'population_result', 'place': 'Canada', 'population': '38.93 million', 'year': '2022'}I should check the source of the data to ensure it is reliable. Action: Search Action Input: "population of Canada source"The 2021 Canadian census enumerated a total population of 36,991,981, an increase of around 5.2 percent over the 2016 figure. It is estimated that Canada's population surpassed 40 million in 2023 and 41 million in 2024. I now know the final answer. Final Answer: The estimated population of Canada in 2022 is 38.93 million. > Finished chain. {'input': 'How many people live in canada?', 'output': 'The estimated population of Canada in 2022 is 38.93 million.'} agent_executor_without_memory.invoke({"input": "what is their national anthem called?"}) > Entering new AgentExecutor chain... I should search for the country's name and "national anthem" Action: Search Action Input: "country name" national anthem['"Liberté" ("Freedom") · "Esta É a Nossa Pátria Bem Amada" ("This Is Our Beloved Country") · "Dear Land of Guyana, of Rivers and Plains" · "La Dessalinienne" ("Song ...', 'National Anthem of Every Country ; Fiji, “Meda Dau Doka” (“God Bless Fiji”) ; Finland, “Maamme”. (“Our Land”) ; France, “La Marseillaise” (“The Marseillaise”).', 'List of national anthems ; Albania · Hymni i Flamurit · Algeria ; The Bahamas · March On, Bahamaland · Bahrain ; Cambodia · Nokoreach · Cameroon ; Madagascar · Ry ...', 'General information: Hatikvah (the Hope) is now firmly established as the Anthem of the State of Israel as well as the Jewish National Anthem. 1. While yet ...', 'National anthem · Afghanistan · Akrotiri · Albania · Algeria · American Samoa · Andorra · Angola · Anguilla.', 'Background > National anthems: Countries Compared ; IndonesiaIndonesia, Indonesia Raya ( Great Indonesia ) ; IranIran, Soroud-e Melli-e Jomhouri-e Eslami-e Iran ( ...', '1. Afghanistan, "Milli Surood" (National Anthem) · 2. Armenia, "Mer Hayrenik" (Our Fatherland) · 3. Azerbaijan (a transcontinental country with ...', 'National Anthems of all the countries of the world ; Star Spangled Banner with Lyrics, Vocals, and Beautiful Photos. Musicplay ; Russia National ...', "The countries with the ten newest anthem additions adopted them between 2006 to as recently as 2021. Let's take a look: ... Afghanistan's “Dā də bātorāno kor” (“ ..."]I now know the final answer Final Answer: The national anthem of Afghanistan is called "Milli Surood". > Finished chain. {'input': 'what is their national anthem called?', 'output': 'The national anthem of Afghanistan is called "Milli Surood".'}

https://python.langchain.com/docs/modules/memory/chat_messages/

One of the core utility classes underpinning most (if not all) memory modules is the `ChatMessageHistory` class. This is a super lightweight wrapper that provides convenience methods for saving HumanMessages, AIMessages, and then fetching them all. You may want to use this class directly if you are managing memory outside of a chain. ``` [HumanMessage(content='hi!', additional_kwargs={}), AIMessage(content='whats up?', additional_kwargs={})] ```

One of the core utility classes underpinning most (if not all) memory modules is the ChatMessageHistory class. This is a super lightweight wrapper that provides convenience methods for saving HumanMessages, AIMessages, and then fetching them all. You may want to use this class directly if you are managing memory outside of a chain. [HumanMessage(content='hi!', additional_kwargs={}), AIMessage(content='whats up?', additional_kwargs={})]

https://python.langchain.com/docs/modules/data_connection/retrievers/custom_retriever/

## Custom Retriever ## Overview[​](#overview "Direct link to Overview") Many LLM applications involve retrieving information from external data sources using a `Retriever`. A retriever is responsible for retrieving a list of relevant `Documents` to a given user `query`. The retrieved documents are often formatted into prompts that are fed into an LLM, allowing the LLM to use the information in the to generate an appropriate response (e.g., answering a user question based on a knowledge base). ## Interface[​](#interface "Direct link to Interface") To create your own retriever, you need to extend the `BaseRetriever` class and implement the following methods: | Method | Description | Required/Optional | | --- | --- | --- | | `_get_relevant_documents` | Get documents relevant to a query. | Required | | `_aget_relevant_documents` | Implement to provide async native support. | Optional | The logic inside of `_get_relevant_documents` can involve arbitrary calls to a database or to the web using requests. tip By inherting from `BaseRetriever`, your retriever automatically becomes a LangChain [Runnable](https://python.langchain.com/docs/expression_language/interface/) and will gain the standard `Runnable` functionality out of the box! You can use a `RunnableLambda` or `RunnableGenerator` to implement a retriever. The main benefit of implementing a retriever as a `BaseRetriever` vs. a `RunnableLambda` (a custom [runnable function](https://python.langchain.com/docs/expression_language/primitives/functions/)) is that a `BaseRetriever` is a well known LangChain entity so some tooling for monitoring may implement specialized behavior for retrievers. Another difference is that a `BaseRetriever` will behave slightly differently from `RunnableLambda` in some APIs; e.g., the `start` event in `astream_events` API will be `on_retriever_start` instead of `on_chain_start`. ## Example[​](#example "Direct link to Example") Let’s implement a toy retriever that returns all documents whose text contains the text in the user query. ``` from typing import Listfrom langchain_core.callbacks import CallbackManagerForRetrieverRunfrom langchain_core.documents import Documentfrom langchain_core.retrievers import BaseRetrieverclass ToyRetriever(BaseRetriever): """A toy retriever that contains the top k documents that contain the user query. This retriever only implements the sync method _get_relevant_documents. If the retriever were to involve file access or network access, it could benefit from a native async implementation of `_aget_relevant_documents`. As usual, with Runnables, there's a default async implementation that's provided that delegates to the sync implementation running on another thread. """ documents: List[Document] """List of documents to retrieve from.""" k: int """Number of top results to return""" def _get_relevant_documents( self, query: str, *, run_manager: CallbackManagerForRetrieverRun ) -> List[Document]: """Sync implementations for retriever.""" matching_documents = [] for document in documents: if len(matching_documents) > self.k: return matching_documents if query.lower() in document.page_content.lower(): matching_documents.append(document) return matching_documents # Optional: Provide a more efficient native implementation by overriding # _aget_relevant_documents # async def _aget_relevant_documents( # self, query: str, *, run_manager: AsyncCallbackManagerForRetrieverRun # ) -> List[Document]: # """Asynchronously get documents relevant to a query. # Args: # query: String to find relevant documents for # run_manager: The callbacks handler to use # Returns: # List of relevant documents # """ ``` ## Test it 🧪[​](#test-it "Direct link to Test it 🧪") ``` documents = [ Document( page_content="Dogs are great companions, known for their loyalty and friendliness.", metadata={"type": "dog", "trait": "loyalty"}, ), Document( page_content="Cats are independent pets that often enjoy their own space.", metadata={"type": "cat", "trait": "independence"}, ), Document( page_content="Goldfish are popular pets for beginners, requiring relatively simple care.", metadata={"type": "fish", "trait": "low maintenance"}, ), Document( page_content="Parrots are intelligent birds capable of mimicking human speech.", metadata={"type": "bird", "trait": "intelligence"}, ), Document( page_content="Rabbits are social animals that need plenty of space to hop around.", metadata={"type": "rabbit", "trait": "social"}, ),]retriever = ToyRetriever(documents=documents, k=3) ``` ``` [Document(page_content='Cats are independent pets that often enjoy their own space.', metadata={'type': 'cat', 'trait': 'independence'}), Document(page_content='Rabbits are social animals that need plenty of space to hop around.', metadata={'type': 'rabbit', 'trait': 'social'})] ``` It’s a **runnable** so it’ll benefit from the standard Runnable Interface! 🤩 ``` await retriever.ainvoke("that") ``` ``` [Document(page_content='Cats are independent pets that often enjoy their own space.', metadata={'type': 'cat', 'trait': 'independence'}), Document(page_content='Rabbits are social animals that need plenty of space to hop around.', metadata={'type': 'rabbit', 'trait': 'social'})] ``` ``` retriever.batch(["dog", "cat"]) ``` ``` [[Document(page_content='Dogs are great companions, known for their loyalty and friendliness.', metadata={'type': 'dog', 'trait': 'loyalty'})], [Document(page_content='Cats are independent pets that often enjoy their own space.', metadata={'type': 'cat', 'trait': 'independence'})]] ``` ``` async for event in retriever.astream_events("bar", version="v1"): print(event) ``` ``` {'event': 'on_retriever_start', 'run_id': 'f96f268d-8383-4921-b175-ca583924d9ff', 'name': 'ToyRetriever', 'tags': [], 'metadata': {}, 'data': {'input': 'bar'}}{'event': 'on_retriever_stream', 'run_id': 'f96f268d-8383-4921-b175-ca583924d9ff', 'tags': [], 'metadata': {}, 'name': 'ToyRetriever', 'data': {'chunk': []}}{'event': 'on_retriever_end', 'name': 'ToyRetriever', 'run_id': 'f96f268d-8383-4921-b175-ca583924d9ff', 'tags': [], 'metadata': {}, 'data': {'output': []}} ``` ## Contributing[​](#contributing "Direct link to Contributing") We appreciate contributions of interesting retrievers! Here’s a checklist to help make sure your contribution gets added to LangChain: Documentation: * The retriever contains doc-strings for all initialization arguments, as these will be surfaced in the [API Reference](https://api.python.langchain.com/en/stable/langchain_api_reference.html). * The class doc-string for the model contains a link to any relevant APIs used for the retriever (e.g., if the retriever is retrieving from wikipedia, it’ll be good to link to the wikipedia API!) Tests: * ☐ Add unit or integration tests to verify that `invoke` and `ainvoke` work. Optimizations: If the retriever is connecting to external data sources (e.g., an API or a file), it’ll almost certainly benefit from an async native optimization! * ☐ Provide a native async implementation of `_aget_relevant_documents` (used by `ainvoke`)

Custom Retriever Overview​ Many LLM applications involve retrieving information from external data sources using a Retriever. A retriever is responsible for retrieving a list of relevant Documents to a given user query. The retrieved documents are often formatted into prompts that are fed into an LLM, allowing the LLM to use the information in the to generate an appropriate response (e.g., answering a user question based on a knowledge base). Interface​ To create your own retriever, you need to extend the BaseRetriever class and implement the following methods: MethodDescriptionRequired/Optional _get_relevant_documents Get documents relevant to a query. Required _aget_relevant_documents Implement to provide async native support. Optional The logic inside of _get_relevant_documents can involve arbitrary calls to a database or to the web using requests. tip By inherting from BaseRetriever, your retriever automatically becomes a LangChain Runnable and will gain the standard Runnable functionality out of the box! You can use a RunnableLambda or RunnableGenerator to implement a retriever. The main benefit of implementing a retriever as a BaseRetriever vs. a RunnableLambda (a custom runnable function) is that a BaseRetriever is a well known LangChain entity so some tooling for monitoring may implement specialized behavior for retrievers. Another difference is that a BaseRetriever will behave slightly differently from RunnableLambda in some APIs; e.g., the start event in astream_events API will be on_retriever_start instead of on_chain_start. Example​ Let’s implement a toy retriever that returns all documents whose text contains the text in the user query. from typing import List from langchain_core.callbacks import CallbackManagerForRetrieverRun from langchain_core.documents import Document from langchain_core.retrievers import BaseRetriever class ToyRetriever(BaseRetriever): """A toy retriever that contains the top k documents that contain the user query. This retriever only implements the sync method _get_relevant_documents. If the retriever were to involve file access or network access, it could benefit from a native async implementation of `_aget_relevant_documents`. As usual, with Runnables, there's a default async implementation that's provided that delegates to the sync implementation running on another thread. """ documents: List[Document] """List of documents to retrieve from.""" k: int """Number of top results to return""" def _get_relevant_documents( self, query: str, *, run_manager: CallbackManagerForRetrieverRun ) -> List[Document]: """Sync implementations for retriever.""" matching_documents = [] for document in documents: if len(matching_documents) > self.k: return matching_documents if query.lower() in document.page_content.lower(): matching_documents.append(document) return matching_documents # Optional: Provide a more efficient native implementation by overriding # _aget_relevant_documents # async def _aget_relevant_documents( # self, query: str, *, run_manager: AsyncCallbackManagerForRetrieverRun # ) -> List[Document]: # """Asynchronously get documents relevant to a query. # Args: # query: String to find relevant documents for # run_manager: The callbacks handler to use # Returns: # List of relevant documents # """ Test it 🧪​ documents = [ Document( page_content="Dogs are great companions, known for their loyalty and friendliness.", metadata={"type": "dog", "trait": "loyalty"}, ), Document( page_content="Cats are independent pets that often enjoy their own space.", metadata={"type": "cat", "trait": "independence"}, ), Document( page_content="Goldfish are popular pets for beginners, requiring relatively simple care.", metadata={"type": "fish", "trait": "low maintenance"}, ), Document( page_content="Parrots are intelligent birds capable of mimicking human speech.", metadata={"type": "bird", "trait": "intelligence"}, ), Document( page_content="Rabbits are social animals that need plenty of space to hop around.", metadata={"type": "rabbit", "trait": "social"}, ), ] retriever = ToyRetriever(documents=documents, k=3) [Document(page_content='Cats are independent pets that often enjoy their own space.', metadata={'type': 'cat', 'trait': 'independence'}), Document(page_content='Rabbits are social animals that need plenty of space to hop around.', metadata={'type': 'rabbit', 'trait': 'social'})] It’s a runnable so it’ll benefit from the standard Runnable Interface! 🤩 await retriever.ainvoke("that") [Document(page_content='Cats are independent pets that often enjoy their own space.', metadata={'type': 'cat', 'trait': 'independence'}), Document(page_content='Rabbits are social animals that need plenty of space to hop around.', metadata={'type': 'rabbit', 'trait': 'social'})] retriever.batch(["dog", "cat"]) [[Document(page_content='Dogs are great companions, known for their loyalty and friendliness.', metadata={'type': 'dog', 'trait': 'loyalty'})], [Document(page_content='Cats are independent pets that often enjoy their own space.', metadata={'type': 'cat', 'trait': 'independence'})]] async for event in retriever.astream_events("bar", version="v1"): print(event) {'event': 'on_retriever_start', 'run_id': 'f96f268d-8383-4921-b175-ca583924d9ff', 'name': 'ToyRetriever', 'tags': [], 'metadata': {}, 'data': {'input': 'bar'}} {'event': 'on_retriever_stream', 'run_id': 'f96f268d-8383-4921-b175-ca583924d9ff', 'tags': [], 'metadata': {}, 'name': 'ToyRetriever', 'data': {'chunk': []}} {'event': 'on_retriever_end', 'name': 'ToyRetriever', 'run_id': 'f96f268d-8383-4921-b175-ca583924d9ff', 'tags': [], 'metadata': {}, 'data': {'output': []}} Contributing​ We appreciate contributions of interesting retrievers! Here’s a checklist to help make sure your contribution gets added to LangChain: Documentation: The retriever contains doc-strings for all initialization arguments, as these will be surfaced in the API Reference. The class doc-string for the model contains a link to any relevant APIs used for the retriever (e.g., if the retriever is retrieving from wikipedia, it’ll be good to link to the wikipedia API!) Tests: ☐ Add unit or integration tests to verify that invoke and ainvoke work. Optimizations: If the retriever is connecting to external data sources (e.g., an API or a file), it’ll almost certainly benefit from an async native optimization! ☐ Provide a native async implementation of _aget_relevant_documents (used by ainvoke)

https://python.langchain.com/docs/modules/data_connection/retrievers/ensemble/

## Ensemble Retriever The `EnsembleRetriever` takes a list of retrievers as input and ensemble the results of their `get_relevant_documents()` methods and rerank the results based on the [Reciprocal Rank Fusion](https://plg.uwaterloo.ca/~gvcormac/cormacksigir09-rrf.pdf) algorithm. By leveraging the strengths of different algorithms, the `EnsembleRetriever` can achieve better performance than any single algorithm. The most common pattern is to combine a sparse retriever (like BM25) with a dense retriever (like embedding similarity), because their strengths are complementary. It is also known as “hybrid search”. The sparse retriever is good at finding relevant documents based on keywords, while the dense retriever is good at finding relevant documents based on semantic similarity. ``` %pip install --upgrade --quiet rank_bm25 > /dev/null ``` ``` from langchain.retrievers import EnsembleRetrieverfrom langchain_community.retrievers import BM25Retrieverfrom langchain_community.vectorstores import FAISSfrom langchain_openai import OpenAIEmbeddings ``` ``` doc_list_1 = [ "I like apples", "I like oranges", "Apples and oranges are fruits",]# initialize the bm25 retriever and faiss retrieverbm25_retriever = BM25Retriever.from_texts( doc_list_1, metadatas=[{"source": 1}] * len(doc_list_1))bm25_retriever.k = 2doc_list_2 = [ "You like apples", "You like oranges",]embedding = OpenAIEmbeddings()faiss_vectorstore = FAISS.from_texts( doc_list_2, embedding, metadatas=[{"source": 2}] * len(doc_list_2))faiss_retriever = faiss_vectorstore.as_retriever(search_kwargs={"k": 2})# initialize the ensemble retrieverensemble_retriever = EnsembleRetriever( retrievers=[bm25_retriever, faiss_retriever], weights=[0.5, 0.5]) ``` ``` docs = ensemble_retriever.invoke("apples")docs ``` ``` [Document(page_content='You like apples', metadata={'source': 2}), Document(page_content='I like apples', metadata={'source': 1}), Document(page_content='You like oranges', metadata={'source': 2}), Document(page_content='Apples and oranges are fruits', metadata={'source': 1})] ``` ## Runtime Configuration[​](#runtime-configuration "Direct link to Runtime Configuration") We can also configure the retrievers at runtime. In order to do this, we need to mark the fields as configurable ``` from langchain_core.runnables import ConfigurableField ``` ``` faiss_retriever = faiss_vectorstore.as_retriever( search_kwargs={"k": 2}).configurable_fields( search_kwargs=ConfigurableField( id="search_kwargs_faiss", name="Search Kwargs", description="The search kwargs to use", )) ``` ``` ensemble_retriever = EnsembleRetriever( retrievers=[bm25_retriever, faiss_retriever], weights=[0.5, 0.5]) ``` ``` config = {"configurable": {"search_kwargs_faiss": {"k": 1}}}docs = ensemble_retriever.invoke("apples", config=config)docs ``` Notice that this only returns one source from the FAISS retriever, because we pass in the relevant configuration at run time

Ensemble Retriever The EnsembleRetriever takes a list of retrievers as input and ensemble the results of their get_relevant_documents() methods and rerank the results based on the Reciprocal Rank Fusion algorithm. By leveraging the strengths of different algorithms, the EnsembleRetriever can achieve better performance than any single algorithm. The most common pattern is to combine a sparse retriever (like BM25) with a dense retriever (like embedding similarity), because their strengths are complementary. It is also known as “hybrid search”. The sparse retriever is good at finding relevant documents based on keywords, while the dense retriever is good at finding relevant documents based on semantic similarity. %pip install --upgrade --quiet rank_bm25 > /dev/null from langchain.retrievers import EnsembleRetriever from langchain_community.retrievers import BM25Retriever from langchain_community.vectorstores import FAISS from langchain_openai import OpenAIEmbeddings doc_list_1 = [ "I like apples", "I like oranges", "Apples and oranges are fruits", ] # initialize the bm25 retriever and faiss retriever bm25_retriever = BM25Retriever.from_texts( doc_list_1, metadatas=[{"source": 1}] * len(doc_list_1) ) bm25_retriever.k = 2 doc_list_2 = [ "You like apples", "You like oranges", ] embedding = OpenAIEmbeddings() faiss_vectorstore = FAISS.from_texts( doc_list_2, embedding, metadatas=[{"source": 2}] * len(doc_list_2) ) faiss_retriever = faiss_vectorstore.as_retriever(search_kwargs={"k": 2}) # initialize the ensemble retriever ensemble_retriever = EnsembleRetriever( retrievers=[bm25_retriever, faiss_retriever], weights=[0.5, 0.5] ) docs = ensemble_retriever.invoke("apples") docs [Document(page_content='You like apples', metadata={'source': 2}), Document(page_content='I like apples', metadata={'source': 1}), Document(page_content='You like oranges', metadata={'source': 2}), Document(page_content='Apples and oranges are fruits', metadata={'source': 1})] Runtime Configuration​ We can also configure the retrievers at runtime. In order to do this, we need to mark the fields as configurable from langchain_core.runnables import ConfigurableField faiss_retriever = faiss_vectorstore.as_retriever( search_kwargs={"k": 2} ).configurable_fields( search_kwargs=ConfigurableField( id="search_kwargs_faiss", name="Search Kwargs", description="The search kwargs to use", ) ) ensemble_retriever = EnsembleRetriever( retrievers=[bm25_retriever, faiss_retriever], weights=[0.5, 0.5] ) config = {"configurable": {"search_kwargs_faiss": {"k": 1}}} docs = ensemble_retriever.invoke("apples", config=config) docs Notice that this only returns one source from the FAISS retriever, because we pass in the relevant configuration at run time

https://python.langchain.com/docs/modules/data_connection/retrievers/contextual_compression/

## Contextual compression One challenge with retrieval is that usually you don’t know the specific queries your document storage system will face when you ingest data into the system. This means that the information most relevant to a query may be buried in a document with a lot of irrelevant text. Passing that full document through your application can lead to more expensive LLM calls and poorer responses. Contextual compression is meant to fix this. The idea is simple: instead of immediately returning retrieved documents as-is, you can compress them using the context of the given query, so that only the relevant information is returned. “Compressing” here refers to both compressing the contents of an individual document and filtering out documents wholesale. To use the Contextual Compression Retriever, you’ll need: - a base retriever - a Document Compressor The Contextual Compression Retriever passes queries to the base retriever, takes the initial documents and passes them through the Document Compressor. The Document Compressor takes a list of documents and shortens it by reducing the contents of documents or dropping documents altogether.  ## Get started[​](#get-started "Direct link to Get started") ``` # Helper function for printing docsdef pretty_print_docs(docs): print( f"\n{'-' * 100}\n".join( [f"Document {i+1}:\n\n" + d.page_content for i, d in enumerate(docs)] ) ) ``` ## Using a vanilla vector store retriever[​](#using-a-vanilla-vector-store-retriever "Direct link to Using a vanilla vector store retriever") Let’s start by initializing a simple vector store retriever and storing the 2023 State of the Union speech (in chunks). We can see that given an example question our retriever returns one or two relevant docs and a few irrelevant docs. And even the relevant docs have a lot of irrelevant information in them. ``` from langchain_community.document_loaders import TextLoaderfrom langchain_community.vectorstores import FAISSfrom langchain_openai import OpenAIEmbeddingsfrom langchain_text_splitters import CharacterTextSplitterdocuments = TextLoader("../../state_of_the_union.txt").load()text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)texts = text_splitter.split_documents(documents)retriever = FAISS.from_documents(texts, OpenAIEmbeddings()).as_retriever()docs = retriever.get_relevant_documents( "What did the president say about Ketanji Brown Jackson")pretty_print_docs(docs) ``` ``` Document 1:Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.----------------------------------------------------------------------------------------------------Document 2:A former top litigator in private practice. A former federal public defender. And from a family of public school educators and police officers. A consensus builder. Since she’s been nominated, she’s received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans. And if we are to advance liberty and justice, we need to secure the Border and fix the immigration system. We can do both. At our border, we’ve installed new technology like cutting-edge scanners to better detect drug smuggling. We’ve set up joint patrols with Mexico and Guatemala to catch more human traffickers. We’re putting in place dedicated immigration judges so families fleeing persecution and violence can have their cases heard faster. We’re securing commitments and supporting partners in South and Central America to host more refugees and secure their own borders.----------------------------------------------------------------------------------------------------Document 3:And for our LGBTQ+ Americans, let’s finally get the bipartisan Equality Act to my desk. The onslaught of state laws targeting transgender Americans and their families is wrong. As I said last year, especially to our younger transgender Americans, I will always have your back as your President, so you can be yourself and reach your God-given potential. While it often appears that we never agree, that isn’t true. I signed 80 bipartisan bills into law last year. From preventing government shutdowns to protecting Asian-Americans from still-too-common hate crimes to reforming military justice. And soon, we’ll strengthen the Violence Against Women Act that I first wrote three decades ago. It is important for us to show the nation that we can come together and do big things. So tonight I’m offering a Unity Agenda for the Nation. Four big things we can do together. First, beat the opioid epidemic.----------------------------------------------------------------------------------------------------Document 4:Tonight, I’m announcing a crackdown on these companies overcharging American businesses and consumers. And as Wall Street firms take over more nursing homes, quality in those homes has gone down and costs have gone up. That ends on my watch. Medicare is going to set higher standards for nursing homes and make sure your loved ones get the care they deserve and expect. We’ll also cut costs and keep the economy going strong by giving workers a fair shot, provide more training and apprenticeships, hire them based on their skills not degrees. Let’s pass the Paycheck Fairness Act and paid leave. Raise the minimum wage to $15 an hour and extend the Child Tax Credit, so no one has to raise a family in poverty. Let’s increase Pell Grants and increase our historic support of HBCUs, and invest in what Jill—our First Lady who teaches full-time—calls America’s best-kept secret: community colleges. ``` Now let’s wrap our base retriever with a `ContextualCompressionRetriever`. We’ll add an `LLMChainExtractor`, which will iterate over the initially returned documents and extract from each only the content that is relevant to the query. ``` from langchain.retrievers import ContextualCompressionRetrieverfrom langchain.retrievers.document_compressors import LLMChainExtractorfrom langchain_openai import OpenAIllm = OpenAI(temperature=0)compressor = LLMChainExtractor.from_llm(llm)compression_retriever = ContextualCompressionRetriever( base_compressor=compressor, base_retriever=retriever)compressed_docs = compression_retriever.get_relevant_documents( "What did the president say about Ketanji Jackson Brown")pretty_print_docs(compressed_docs) ``` ``` /Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain. warnings.warn(/Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain. warnings.warn(/Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain. warnings.warn(/Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain. warnings.warn( ``` ``` Document 1:I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. ``` ## More built-in compressors: filters[​](#more-built-in-compressors-filters "Direct link to More built-in compressors: filters") ### `LLMChainFilter`[​](#llmchainfilter "Direct link to llmchainfilter") The `LLMChainFilter` is slightly simpler but more robust compressor that uses an LLM chain to decide which of the initially retrieved documents to filter out and which ones to return, without manipulating the document contents. ``` from langchain.retrievers.document_compressors import LLMChainFilter_filter = LLMChainFilter.from_llm(llm)compression_retriever = ContextualCompressionRetriever( base_compressor=_filter, base_retriever=retriever)compressed_docs = compression_retriever.get_relevant_documents( "What did the president say about Ketanji Jackson Brown")pretty_print_docs(compressed_docs) ``` ``` /Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain. warnings.warn(/Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain. warnings.warn(/Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain. warnings.warn(/Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain. warnings.warn( ``` ``` Document 1:Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. ``` ### `EmbeddingsFilter`[​](#embeddingsfilter "Direct link to embeddingsfilter") Making an extra LLM call over each retrieved document is expensive and slow. The `EmbeddingsFilter` provides a cheaper and faster option by embedding the documents and query and only returning those documents which have sufficiently similar embeddings to the query. ``` from langchain.retrievers.document_compressors import EmbeddingsFilterfrom langchain_openai import OpenAIEmbeddingsembeddings = OpenAIEmbeddings()embeddings_filter = EmbeddingsFilter(embeddings=embeddings, similarity_threshold=0.76)compression_retriever = ContextualCompressionRetriever( base_compressor=embeddings_filter, base_retriever=retriever)compressed_docs = compression_retriever.get_relevant_documents( "What did the president say about Ketanji Jackson Brown")pretty_print_docs(compressed_docs) ``` ``` Document 1:Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.----------------------------------------------------------------------------------------------------Document 2:A former top litigator in private practice. A former federal public defender. And from a family of public school educators and police officers. A consensus builder. Since she’s been nominated, she’s received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans. And if we are to advance liberty and justice, we need to secure the Border and fix the immigration system. We can do both. At our border, we’ve installed new technology like cutting-edge scanners to better detect drug smuggling. We’ve set up joint patrols with Mexico and Guatemala to catch more human traffickers. We’re putting in place dedicated immigration judges so families fleeing persecution and violence can have their cases heard faster. We’re securing commitments and supporting partners in South and Central America to host more refugees and secure their own borders.----------------------------------------------------------------------------------------------------Document 3:And for our LGBTQ+ Americans, let’s finally get the bipartisan Equality Act to my desk. The onslaught of state laws targeting transgender Americans and their families is wrong. As I said last year, especially to our younger transgender Americans, I will always have your back as your President, so you can be yourself and reach your God-given potential. While it often appears that we never agree, that isn’t true. I signed 80 bipartisan bills into law last year. From preventing government shutdowns to protecting Asian-Americans from still-too-common hate crimes to reforming military justice. And soon, we’ll strengthen the Violence Against Women Act that I first wrote three decades ago. It is important for us to show the nation that we can come together and do big things. So tonight I’m offering a Unity Agenda for the Nation. Four big things we can do together. First, beat the opioid epidemic. ``` ## Stringing compressors and document transformers together[​](#stringing-compressors-and-document-transformers-together "Direct link to Stringing compressors and document transformers together") Using the `DocumentCompressorPipeline` we can also easily combine multiple compressors in sequence. Along with compressors we can add `BaseDocumentTransformer`s to our pipeline, which don’t perform any contextual compression but simply perform some transformation on a set of documents. For example `TextSplitter`s can be used as document transformers to split documents into smaller pieces, and the `EmbeddingsRedundantFilter` can be used to filter out redundant documents based on embedding similarity between documents. Below we create a compressor pipeline by first splitting our docs into smaller chunks, then removing redundant documents, and then filtering based on relevance to the query. ``` from langchain.retrievers.document_compressors import DocumentCompressorPipelinefrom langchain_community.document_transformers import EmbeddingsRedundantFilterfrom langchain_text_splitters import CharacterTextSplittersplitter = CharacterTextSplitter(chunk_size=300, chunk_overlap=0, separator=". ")redundant_filter = EmbeddingsRedundantFilter(embeddings=embeddings)relevant_filter = EmbeddingsFilter(embeddings=embeddings, similarity_threshold=0.76)pipeline_compressor = DocumentCompressorPipeline( transformers=[splitter, redundant_filter, relevant_filter]) ``` ``` compression_retriever = ContextualCompressionRetriever( base_compressor=pipeline_compressor, base_retriever=retriever)compressed_docs = compression_retriever.get_relevant_documents( "What did the president say about Ketanji Jackson Brown")pretty_print_docs(compressed_docs) ``` ``` Document 1:One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson----------------------------------------------------------------------------------------------------Document 2:As I said last year, especially to our younger transgender Americans, I will always have your back as your President, so you can be yourself and reach your God-given potential. While it often appears that we never agree, that isn’t true. I signed 80 bipartisan bills into law last year----------------------------------------------------------------------------------------------------Document 3:A former top litigator in private practice. A former federal public defender. And from a family of public school educators and police officers. A consensus builder----------------------------------------------------------------------------------------------------Document 4:Since she’s been nominated, she’s received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans. And if we are to advance liberty and justice, we need to secure the Border and fix the immigration system. We can do both ```

Contextual compression One challenge with retrieval is that usually you don’t know the specific queries your document storage system will face when you ingest data into the system. This means that the information most relevant to a query may be buried in a document with a lot of irrelevant text. Passing that full document through your application can lead to more expensive LLM calls and poorer responses. Contextual compression is meant to fix this. The idea is simple: instead of immediately returning retrieved documents as-is, you can compress them using the context of the given query, so that only the relevant information is returned. “Compressing” here refers to both compressing the contents of an individual document and filtering out documents wholesale. To use the Contextual Compression Retriever, you’ll need: - a base retriever - a Document Compressor The Contextual Compression Retriever passes queries to the base retriever, takes the initial documents and passes them through the Document Compressor. The Document Compressor takes a list of documents and shortens it by reducing the contents of documents or dropping documents altogether. Get started​ # Helper function for printing docs def pretty_print_docs(docs): print( f"\n{'-' * 100}\n".join( [f"Document {i+1}:\n\n" + d.page_content for i, d in enumerate(docs)] ) ) Using a vanilla vector store retriever​ Let’s start by initializing a simple vector store retriever and storing the 2023 State of the Union speech (in chunks). We can see that given an example question our retriever returns one or two relevant docs and a few irrelevant docs. And even the relevant docs have a lot of irrelevant information in them. from langchain_community.document_loaders import TextLoader from langchain_community.vectorstores import FAISS from langchain_openai import OpenAIEmbeddings from langchain_text_splitters import CharacterTextSplitter documents = TextLoader("../../state_of_the_union.txt").load() text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0) texts = text_splitter.split_documents(documents) retriever = FAISS.from_documents(texts, OpenAIEmbeddings()).as_retriever() docs = retriever.get_relevant_documents( "What did the president say about Ketanji Brown Jackson" ) pretty_print_docs(docs) Document 1: Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. ---------------------------------------------------------------------------------------------------- Document 2: A former top litigator in private practice. A former federal public defender. And from a family of public school educators and police officers. A consensus builder. Since she’s been nominated, she’s received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans. And if we are to advance liberty and justice, we need to secure the Border and fix the immigration system. We can do both. At our border, we’ve installed new technology like cutting-edge scanners to better detect drug smuggling. We’ve set up joint patrols with Mexico and Guatemala to catch more human traffickers. We’re putting in place dedicated immigration judges so families fleeing persecution and violence can have their cases heard faster. We’re securing commitments and supporting partners in South and Central America to host more refugees and secure their own borders. ---------------------------------------------------------------------------------------------------- Document 3: And for our LGBTQ+ Americans, let’s finally get the bipartisan Equality Act to my desk. The onslaught of state laws targeting transgender Americans and their families is wrong. As I said last year, especially to our younger transgender Americans, I will always have your back as your President, so you can be yourself and reach your God-given potential. While it often appears that we never agree, that isn’t true. I signed 80 bipartisan bills into law last year. From preventing government shutdowns to protecting Asian-Americans from still-too-common hate crimes to reforming military justice. And soon, we’ll strengthen the Violence Against Women Act that I first wrote three decades ago. It is important for us to show the nation that we can come together and do big things. So tonight I’m offering a Unity Agenda for the Nation. Four big things we can do together. First, beat the opioid epidemic. ---------------------------------------------------------------------------------------------------- Document 4: Tonight, I’m announcing a crackdown on these companies overcharging American businesses and consumers. And as Wall Street firms take over more nursing homes, quality in those homes has gone down and costs have gone up. That ends on my watch. Medicare is going to set higher standards for nursing homes and make sure your loved ones get the care they deserve and expect. We’ll also cut costs and keep the economy going strong by giving workers a fair shot, provide more training and apprenticeships, hire them based on their skills not degrees. Let’s pass the Paycheck Fairness Act and paid leave. Raise the minimum wage to $15 an hour and extend the Child Tax Credit, so no one has to raise a family in poverty. Let’s increase Pell Grants and increase our historic support of HBCUs, and invest in what Jill—our First Lady who teaches full-time—calls America’s best-kept secret: community colleges. Now let’s wrap our base retriever with a ContextualCompressionRetriever. We’ll add an LLMChainExtractor, which will iterate over the initially returned documents and extract from each only the content that is relevant to the query. from langchain.retrievers import ContextualCompressionRetriever from langchain.retrievers.document_compressors import LLMChainExtractor from langchain_openai import OpenAI llm = OpenAI(temperature=0) compressor = LLMChainExtractor.from_llm(llm) compression_retriever = ContextualCompressionRetriever( base_compressor=compressor, base_retriever=retriever ) compressed_docs = compression_retriever.get_relevant_documents( "What did the president say about Ketanji Jackson Brown" ) pretty_print_docs(compressed_docs) /Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain. warnings.warn( /Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain. warnings.warn( /Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain. warnings.warn( /Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain. warnings.warn( Document 1: I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. More built-in compressors: filters​ LLMChainFilter​ The LLMChainFilter is slightly simpler but more robust compressor that uses an LLM chain to decide which of the initially retrieved documents to filter out and which ones to return, without manipulating the document contents. from langchain.retrievers.document_compressors import LLMChainFilter _filter = LLMChainFilter.from_llm(llm) compression_retriever = ContextualCompressionRetriever( base_compressor=_filter, base_retriever=retriever ) compressed_docs = compression_retriever.get_relevant_documents( "What did the president say about Ketanji Jackson Brown" ) pretty_print_docs(compressed_docs) /Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain. warnings.warn( /Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain. warnings.warn( /Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain. warnings.warn( /Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain. warnings.warn( Document 1: Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. EmbeddingsFilter​ Making an extra LLM call over each retrieved document is expensive and slow. The EmbeddingsFilter provides a cheaper and faster option by embedding the documents and query and only returning those documents which have sufficiently similar embeddings to the query. from langchain.retrievers.document_compressors import EmbeddingsFilter from langchain_openai import OpenAIEmbeddings embeddings = OpenAIEmbeddings() embeddings_filter = EmbeddingsFilter(embeddings=embeddings, similarity_threshold=0.76) compression_retriever = ContextualCompressionRetriever( base_compressor=embeddings_filter, base_retriever=retriever ) compressed_docs = compression_retriever.get_relevant_documents( "What did the president say about Ketanji Jackson Brown" ) pretty_print_docs(compressed_docs) Document 1: Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. ---------------------------------------------------------------------------------------------------- Document 2: A former top litigator in private practice. A former federal public defender. And from a family of public school educators and police officers. A consensus builder. Since she’s been nominated, she’s received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans. And if we are to advance liberty and justice, we need to secure the Border and fix the immigration system. We can do both. At our border, we’ve installed new technology like cutting-edge scanners to better detect drug smuggling. We’ve set up joint patrols with Mexico and Guatemala to catch more human traffickers. We’re putting in place dedicated immigration judges so families fleeing persecution and violence can have their cases heard faster. We’re securing commitments and supporting partners in South and Central America to host more refugees and secure their own borders. ---------------------------------------------------------------------------------------------------- Document 3: And for our LGBTQ+ Americans, let’s finally get the bipartisan Equality Act to my desk. The onslaught of state laws targeting transgender Americans and their families is wrong. As I said last year, especially to our younger transgender Americans, I will always have your back as your President, so you can be yourself and reach your God-given potential. While it often appears that we never agree, that isn’t true. I signed 80 bipartisan bills into law last year. From preventing government shutdowns to protecting Asian-Americans from still-too-common hate crimes to reforming military justice. And soon, we’ll strengthen the Violence Against Women Act that I first wrote three decades ago. It is important for us to show the nation that we can come together and do big things. So tonight I’m offering a Unity Agenda for the Nation. Four big things we can do together. First, beat the opioid epidemic. Stringing compressors and document transformers together​ Using the DocumentCompressorPipeline we can also easily combine multiple compressors in sequence. Along with compressors we can add BaseDocumentTransformers to our pipeline, which don’t perform any contextual compression but simply perform some transformation on a set of documents. For example TextSplitters can be used as document transformers to split documents into smaller pieces, and the EmbeddingsRedundantFilter can be used to filter out redundant documents based on embedding similarity between documents. Below we create a compressor pipeline by first splitting our docs into smaller chunks, then removing redundant documents, and then filtering based on relevance to the query. from langchain.retrievers.document_compressors import DocumentCompressorPipeline from langchain_community.document_transformers import EmbeddingsRedundantFilter from langchain_text_splitters import CharacterTextSplitter splitter = CharacterTextSplitter(chunk_size=300, chunk_overlap=0, separator=". ") redundant_filter = EmbeddingsRedundantFilter(embeddings=embeddings) relevant_filter = EmbeddingsFilter(embeddings=embeddings, similarity_threshold=0.76) pipeline_compressor = DocumentCompressorPipeline( transformers=[splitter, redundant_filter, relevant_filter] ) compression_retriever = ContextualCompressionRetriever( base_compressor=pipeline_compressor, base_retriever=retriever ) compressed_docs = compression_retriever.get_relevant_documents( "What did the president say about Ketanji Jackson Brown" ) pretty_print_docs(compressed_docs) Document 1: One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson ---------------------------------------------------------------------------------------------------- Document 2: As I said last year, especially to our younger transgender Americans, I will always have your back as your President, so you can be yourself and reach your God-given potential. While it often appears that we never agree, that isn’t true. I signed 80 bipartisan bills into law last year ---------------------------------------------------------------------------------------------------- Document 3: A former top litigator in private practice. A former federal public defender. And from a family of public school educators and police officers. A consensus builder ---------------------------------------------------------------------------------------------------- Document 4: Since she’s been nominated, she’s received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans. And if we are to advance liberty and justice, we need to secure the Border and fix the immigration system. We can do both

https://python.langchain.com/docs/modules/data_connection/retrievers/

## Retrievers A retriever is an interface that returns documents given an unstructured query. It is more general than a vector store. A retriever does not need to be able to store documents, only to return (or retrieve) them. Vector stores can be used as the backbone of a retriever, but there are other types of retrievers as well. Retrievers accept a string query as input and return a list of `Document`'s as output. ## Advanced Retrieval Types[​](#advanced-retrieval-types "Direct link to Advanced Retrieval Types") LangChain provides several advanced retrieval types. A full list is below, along with the following information: **Name**: Name of the retrieval algorithm. **Index Type**: Which index type (if any) this relies on. **Uses an LLM**: Whether this retrieval method uses an LLM. **When to Use**: Our commentary on when you should considering using this retrieval method. **Description**: Description of what this retrieval algorithm is doing. | Name | Index Type | Uses an LLM | When to Use | Description | | --- | --- | --- | --- | --- | | [Vectorstore](https://python.langchain.com/docs/modules/data_connection/retrievers/vectorstore/) | Vectorstore | No | If you are just getting started and looking for something quick and easy. | This is the simplest method and the one that is easiest to get started with. It involves creating embeddings for each piece of text. | | [ParentDocument](https://python.langchain.com/docs/modules/data_connection/retrievers/parent_document_retriever/) | Vectorstore + Document Store | No | If your pages have lots of smaller pieces of distinct information that are best indexed by themselves, but best retrieved all together. | This involves indexing multiple chunks for each document. Then you find the chunks that are most similar in embedding space, but you retrieve the whole parent document and return that (rather than individual chunks). | | [Multi Vector](https://python.langchain.com/docs/modules/data_connection/retrievers/multi_vector/) | Vectorstore + Document Store | Sometimes during indexing | If you are able to extract information from documents that you think is more relevant to index than the text itself. | This involves creating multiple vectors for each document. Each vector could be created in a myriad of ways - examples include summaries of the text and hypothetical questions. | | [Self Query](https://python.langchain.com/docs/modules/data_connection/retrievers/self_query/) | Vectorstore | Yes | If users are asking questions that are better answered by fetching documents based on metadata rather than similarity with the text. | This uses an LLM to transform user input into two things: (1) a string to look up semantically, (2) a metadata filer to go along with it. This is useful because oftentimes questions are about the METADATA of documents (not the content itself). | | [Contextual Compression](https://python.langchain.com/docs/modules/data_connection/retrievers/contextual_compression/) | Any | Sometimes | If you are finding that your retrieved documents contain too much irrelevant information and are distracting the LLM. | This puts a post-processing step on top of another retriever and extracts only the most relevant information from retrieved documents. This can be done with embeddings or an LLM. | | [Time-Weighted Vectorstore](https://python.langchain.com/docs/modules/data_connection/retrievers/time_weighted_vectorstore/) | Vectorstore | No | If you have timestamps associated with your documents, and you want to retrieve the most recent ones | This fetches documents based on a combination of semantic similarity (as in normal vector retrieval) and recency (looking at timestamps of indexed documents) | | [Multi-Query Retriever](https://python.langchain.com/docs/modules/data_connection/retrievers/MultiQueryRetriever/) | Any | Yes | If users are asking questions that are complex and require multiple pieces of distinct information to respond | This uses an LLM to generate multiple queries from the original one. This is useful when the original query needs pieces of information about multiple topics to be properly answered. By generating multiple queries, we can then fetch documents for each of them. | | [Ensemble](https://python.langchain.com/docs/modules/data_connection/retrievers/ensemble/) | Any | No | If you have multiple retrieval methods and want to try combining them. | This fetches documents from multiple retrievers and then combines them. | | [Long-Context Reorder](https://python.langchain.com/docs/modules/data_connection/retrievers/long_context_reorder/) | Any | No | If you are working with a long-context model and noticing that it's not paying attention to information in the middle of retrieved documents. | This fetches documents from an underlying retriever, and then reorders them so that the most similar are near the beginning and end. This is useful because it's been shown that for longer context models they sometimes don't pay attention to information in the middle of the context window. | ## [Third Party Integrations](https://python.langchain.com/docs/integrations/retrievers/)[​](#third-party-integrations "Direct link to third-party-integrations") LangChain also integrates with many third-party retrieval services. For a full list of these, check out [this list](https://python.langchain.com/docs/integrations/retrievers/) of all integrations. ## Using Retrievers in LCEL[​](#using-retrievers-in-lcel "Direct link to Using Retrievers in LCEL") Since retrievers are `Runnable`'s, we can easily compose them with other `Runnable` objects: ``` from langchain_openai import ChatOpenAIfrom langchain_core.prompts import ChatPromptTemplatefrom langchain_core.output_parsers import StrOutputParserfrom langchain_core.runnables import RunnablePassthroughtemplate = """Answer the question based only on the following context:{context}Question: {question}"""prompt = ChatPromptTemplate.from_template(template)model = ChatOpenAI()def format_docs(docs): return "\n\n".join([d.page_content for d in docs])chain = ( {"context": retriever | format_docs, "question": RunnablePassthrough()} | prompt | model | StrOutputParser())chain.invoke("What did the president say about technology?") ``` ## Custom Retriever[​](#custom-retriever "Direct link to Custom Retriever") See the [documentation here](https://python.langchain.com/docs/modules/data_connection/retrievers/custom_retriever/) to implement a custom retriever.

Retrievers A retriever is an interface that returns documents given an unstructured query. It is more general than a vector store. A retriever does not need to be able to store documents, only to return (or retrieve) them. Vector stores can be used as the backbone of a retriever, but there are other types of retrievers as well. Retrievers accept a string query as input and return a list of Document's as output. Advanced Retrieval Types​ LangChain provides several advanced retrieval types. A full list is below, along with the following information: Name: Name of the retrieval algorithm. Index Type: Which index type (if any) this relies on. Uses an LLM: Whether this retrieval method uses an LLM. When to Use: Our commentary on when you should considering using this retrieval method. Description: Description of what this retrieval algorithm is doing. NameIndex TypeUses an LLMWhen to UseDescription Vectorstore Vectorstore No If you are just getting started and looking for something quick and easy. This is the simplest method and the one that is easiest to get started with. It involves creating embeddings for each piece of text. ParentDocument Vectorstore + Document Store No If your pages have lots of smaller pieces of distinct information that are best indexed by themselves, but best retrieved all together. This involves indexing multiple chunks for each document. Then you find the chunks that are most similar in embedding space, but you retrieve the whole parent document and return that (rather than individual chunks). Multi Vector Vectorstore + Document Store Sometimes during indexing If you are able to extract information from documents that you think is more relevant to index than the text itself. This involves creating multiple vectors for each document. Each vector could be created in a myriad of ways - examples include summaries of the text and hypothetical questions. Self Query Vectorstore Yes If users are asking questions that are better answered by fetching documents based on metadata rather than similarity with the text. This uses an LLM to transform user input into two things: (1) a string to look up semantically, (2) a metadata filer to go along with it. This is useful because oftentimes questions are about the METADATA of documents (not the content itself). Contextual Compression Any Sometimes If you are finding that your retrieved documents contain too much irrelevant information and are distracting the LLM. This puts a post-processing step on top of another retriever and extracts only the most relevant information from retrieved documents. This can be done with embeddings or an LLM. Time-Weighted Vectorstore Vectorstore No If you have timestamps associated with your documents, and you want to retrieve the most recent ones This fetches documents based on a combination of semantic similarity (as in normal vector retrieval) and recency (looking at timestamps of indexed documents) Multi-Query Retriever Any Yes If users are asking questions that are complex and require multiple pieces of distinct information to respond This uses an LLM to generate multiple queries from the original one. This is useful when the original query needs pieces of information about multiple topics to be properly answered. By generating multiple queries, we can then fetch documents for each of them. Ensemble Any No If you have multiple retrieval methods and want to try combining them. This fetches documents from multiple retrievers and then combines them. Long-Context Reorder Any No If you are working with a long-context model and noticing that it's not paying attention to information in the middle of retrieved documents. This fetches documents from an underlying retriever, and then reorders them so that the most similar are near the beginning and end. This is useful because it's been shown that for longer context models they sometimes don't pay attention to information in the middle of the context window. Third Party Integrations​ LangChain also integrates with many third-party retrieval services. For a full list of these, check out this list of all integrations. Using Retrievers in LCEL​ Since retrievers are Runnable's, we can easily compose them with other Runnable objects: from langchain_openai import ChatOpenAI from langchain_core.prompts import ChatPromptTemplate from langchain_core.output_parsers import StrOutputParser from langchain_core.runnables import RunnablePassthrough template = """Answer the question based only on the following context: {context} Question: {question} """ prompt = ChatPromptTemplate.from_template(template) model = ChatOpenAI() def format_docs(docs): return "\n\n".join([d.page_content for d in docs]) chain = ( {"context": retriever | format_docs, "question": RunnablePassthrough()} | prompt | model | StrOutputParser() ) chain.invoke("What did the president say about technology?") Custom Retriever​ See the documentation here to implement a custom retriever.

https://python.langchain.com/docs/modules/memory/conversational_customization/

## Customizing Conversational Memory This notebook walks through a few ways to customize conversational memory. ``` from langchain.chains import ConversationChainfrom langchain.memory import ConversationBufferMemoryfrom langchain_openai import OpenAIllm = OpenAI(temperature=0) ``` ## AI prefix[​](#ai-prefix "Direct link to AI prefix") The first way to do so is by changing the AI prefix in the conversation summary. By default, this is set to “AI”, but you can set this to be anything you want. Note that if you change this, you should also change the prompt used in the chain to reflect this naming change. Let’s walk through an example of that in the example below. ``` # Here it is by default set to "AI"conversation = ConversationChain( llm=llm, verbose=True, memory=ConversationBufferMemory()) ``` ``` conversation.predict(input="Hi there!") ``` ``` > 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: Hi there!AI:> Finished ConversationChain chain. ``` ``` " Hi there! It's nice to meet you. How can I help you today?" ``` ``` conversation.predict(input="What's the weather?") ``` ``` > 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: Hi there!AI: Hi there! It's nice to meet you. How can I help you today?Human: What's the weather?AI:> Finished ConversationChain chain. ``` ``` ' The current weather is sunny and warm with a temperature of 75 degrees Fahrenheit. The forecast for the next few days is sunny with temperatures in the mid-70s.' ``` ``` # Now we can override it and set it to "AI Assistant"from langchain_core.prompts.prompt import PromptTemplatetemplate = """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:{history}Human: {input}AI Assistant:"""PROMPT = PromptTemplate(input_variables=["history", "input"], template=template)conversation = ConversationChain( prompt=PROMPT, llm=llm, verbose=True, memory=ConversationBufferMemory(ai_prefix="AI Assistant"),) ``` ``` conversation.predict(input="Hi there!") ``` ``` > 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: Hi there!AI Assistant:> Finished ConversationChain chain. ``` ``` " Hi there! It's nice to meet you. How can I help you today?" ``` ``` conversation.predict(input="What's the weather?") ``` ``` > 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: Hi there!AI Assistant: Hi there! It's nice to meet you. How can I help you today?Human: What's the weather?AI Assistant:> Finished ConversationChain chain. ``` ``` ' The current weather is sunny and warm with a temperature of 75 degrees Fahrenheit. The forecast for the rest of the day is sunny with a high of 78 degrees and a low of 65 degrees.' ``` ## Human prefix[​](#human-prefix "Direct link to Human prefix") The next way to do so is by changing the Human prefix in the conversation summary. By default, this is set to “Human”, but you can set this to be anything you want. Note that if you change this, you should also change the prompt used in the chain to reflect this naming change. Let’s walk through an example of that in the example below. ``` # Now we can override it and set it to "Friend"from langchain_core.prompts.prompt import PromptTemplatetemplate = """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:{history}Friend: {input}AI:"""PROMPT = PromptTemplate(input_variables=["history", "input"], template=template)conversation = ConversationChain( prompt=PROMPT, llm=llm, verbose=True, memory=ConversationBufferMemory(human_prefix="Friend"),) ``` ``` conversation.predict(input="Hi there!") ``` ``` > 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:Friend: Hi there!AI:> Finished ConversationChain chain. ``` ``` " Hi there! It's nice to meet you. How can I help you today?" ``` ``` conversation.predict(input="What's the weather?") ``` ``` > 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:Friend: Hi there!AI: Hi there! It's nice to meet you. How can I help you today?Friend: What's the weather?AI:> Finished ConversationChain chain. ``` ``` ' The weather right now is sunny and warm with a temperature of 75 degrees Fahrenheit. The forecast for the rest of the day is mostly sunny with a high of 82 degrees.' ```

Customizing Conversational Memory This notebook walks through a few ways to customize conversational memory. from langchain.chains import ConversationChain from langchain.memory import ConversationBufferMemory from langchain_openai import OpenAI llm = OpenAI(temperature=0) AI prefix​ The first way to do so is by changing the AI prefix in the conversation summary. By default, this is set to “AI”, but you can set this to be anything you want. Note that if you change this, you should also change the prompt used in the chain to reflect this naming change. Let’s walk through an example of that in the example below. # Here it is by default set to "AI" conversation = ConversationChain( llm=llm, verbose=True, memory=ConversationBufferMemory() ) conversation.predict(input="Hi there!") > 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: Hi there! AI: > Finished ConversationChain chain. " Hi there! It's nice to meet you. How can I help you today?" conversation.predict(input="What's the weather?") > 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: Hi there! AI: Hi there! It's nice to meet you. How can I help you today? Human: What's the weather? AI: > Finished ConversationChain chain. ' The current weather is sunny and warm with a temperature of 75 degrees Fahrenheit. The forecast for the next few days is sunny with temperatures in the mid-70s.' # Now we can override it and set it to "AI Assistant" from langchain_core.prompts.prompt import PromptTemplate template = """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: {history} Human: {input} AI Assistant:""" PROMPT = PromptTemplate(input_variables=["history", "input"], template=template) conversation = ConversationChain( prompt=PROMPT, llm=llm, verbose=True, memory=ConversationBufferMemory(ai_prefix="AI Assistant"), ) conversation.predict(input="Hi there!") > 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: Hi there! AI Assistant: > Finished ConversationChain chain. " Hi there! It's nice to meet you. How can I help you today?" conversation.predict(input="What's the weather?") > 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: Hi there! AI Assistant: Hi there! It's nice to meet you. How can I help you today? Human: What's the weather? AI Assistant: > Finished ConversationChain chain. ' The current weather is sunny and warm with a temperature of 75 degrees Fahrenheit. The forecast for the rest of the day is sunny with a high of 78 degrees and a low of 65 degrees.' Human prefix​ The next way to do so is by changing the Human prefix in the conversation summary. By default, this is set to “Human”, but you can set this to be anything you want. Note that if you change this, you should also change the prompt used in the chain to reflect this naming change. Let’s walk through an example of that in the example below. # Now we can override it and set it to "Friend" from langchain_core.prompts.prompt import PromptTemplate template = """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: {history} Friend: {input} AI:""" PROMPT = PromptTemplate(input_variables=["history", "input"], template=template) conversation = ConversationChain( prompt=PROMPT, llm=llm, verbose=True, memory=ConversationBufferMemory(human_prefix="Friend"), ) conversation.predict(input="Hi there!") > 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: Friend: Hi there! AI: > Finished ConversationChain chain. " Hi there! It's nice to meet you. How can I help you today?" conversation.predict(input="What's the weather?") > 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: Friend: Hi there! AI: Hi there! It's nice to meet you. How can I help you today? Friend: What's the weather? AI: > Finished ConversationChain chain. ' The weather right now is sunny and warm with a temperature of 75 degrees Fahrenheit. The forecast for the rest of the day is mostly sunny with a high of 82 degrees.'

https://python.langchain.com/docs/modules/data_connection/retrievers/multi_vector/

## MultiVector Retriever It can often be beneficial to store multiple vectors per document. There are multiple use cases where this is beneficial. LangChain has a base `MultiVectorRetriever` which makes querying this type of setup easy. A lot of the complexity lies in how to create the multiple vectors per document. This notebook covers some of the common ways to create those vectors and use the `MultiVectorRetriever`. The methods to create multiple vectors per document include: * Smaller chunks: split a document into smaller chunks, and embed those (this is ParentDocumentRetriever). * Summary: create a summary for each document, embed that along with (or instead of) the document. * Hypothetical questions: create hypothetical questions that each document would be appropriate to answer, embed those along with (or instead of) the document. Note that this also enables another method of adding embeddings - manually. This is great because you can explicitly add questions or queries that should lead to a document being recovered, giving you more control. ``` from langchain.retrievers.multi_vector import MultiVectorRetriever ``` ``` from langchain.storage import InMemoryByteStorefrom langchain_chroma import Chromafrom langchain_community.document_loaders import TextLoaderfrom langchain_openai import OpenAIEmbeddingsfrom langchain_text_splitters import RecursiveCharacterTextSplitter ``` ``` loaders = [ TextLoader("../../paul_graham_essay.txt"), TextLoader("../../state_of_the_union.txt"),]docs = []for loader in loaders: docs.extend(loader.load())text_splitter = RecursiveCharacterTextSplitter(chunk_size=10000)docs = text_splitter.split_documents(docs) ``` ## Smaller chunks[​](#smaller-chunks "Direct link to Smaller chunks") Often times it can be useful to retrieve larger chunks of information, but embed smaller chunks. This allows for embeddings to capture the semantic meaning as closely as possible, but for as much context as possible to be passed downstream. Note that this is what the `ParentDocumentRetriever` does. Here we show what is going on under the hood. ``` # The vectorstore to use to index the child chunksvectorstore = Chroma( collection_name="full_documents", embedding_function=OpenAIEmbeddings())# The storage layer for the parent documentsstore = InMemoryByteStore()id_key = "doc_id"# The retriever (empty to start)retriever = MultiVectorRetriever( vectorstore=vectorstore, byte_store=store, id_key=id_key,)import uuiddoc_ids = [str(uuid.uuid4()) for _ in docs] ``` ``` # The splitter to use to create smaller chunkschild_text_splitter = RecursiveCharacterTextSplitter(chunk_size=400) ``` ``` sub_docs = []for i, doc in enumerate(docs): _id = doc_ids[i] _sub_docs = child_text_splitter.split_documents([doc]) for _doc in _sub_docs: _doc.metadata[id_key] = _id sub_docs.extend(_sub_docs) ``` ``` retriever.vectorstore.add_documents(sub_docs)retriever.docstore.mset(list(zip(doc_ids, docs))) ``` ``` # Vectorstore alone retrieves the small chunksretriever.vectorstore.similarity_search("justice breyer")[0] ``` ``` Document(page_content='Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \n\nOne of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court.', metadata={'doc_id': '2fd77862-9ed5-4fad-bf76-e487b747b333', 'source': '../../state_of_the_union.txt'}) ``` ``` # Retriever returns larger chunkslen(retriever.get_relevant_documents("justice breyer")[0].page_content) ``` The default search type the retriever performs on the vector database is a similarity search. LangChain Vector Stores also support searching via [Max Marginal Relevance](https://api.python.langchain.com/en/latest/vectorstores/langchain_core.vectorstores.VectorStore.html#langchain_core.vectorstores.VectorStore.max_marginal_relevance_search) so if you want this instead you can just set the `search_type` property as follows: ``` from langchain.retrievers.multi_vector import SearchTyperetriever.search_type = SearchType.mmrlen(retriever.get_relevant_documents("justice breyer")[0].page_content) ``` ## Summary[​](#summary "Direct link to Summary") Oftentimes a summary may be able to distill more accurately what a chunk is about, leading to better retrieval. Here we show how to create summaries, and then embed those. ``` import uuidfrom langchain_core.documents import Documentfrom langchain_core.output_parsers import StrOutputParserfrom langchain_core.prompts import ChatPromptTemplatefrom langchain_openai import ChatOpenAI ``` ``` chain = ( {"doc": lambda x: x.page_content} | ChatPromptTemplate.from_template("Summarize the following document:\n\n{doc}") | ChatOpenAI(max_retries=0) | StrOutputParser()) ``` ``` summaries = chain.batch(docs, {"max_concurrency": 5}) ``` ``` # The vectorstore to use to index the child chunksvectorstore = Chroma(collection_name="summaries", embedding_function=OpenAIEmbeddings())# The storage layer for the parent documentsstore = InMemoryByteStore()id_key = "doc_id"# The retriever (empty to start)retriever = MultiVectorRetriever( vectorstore=vectorstore, byte_store=store, id_key=id_key,)doc_ids = [str(uuid.uuid4()) for _ in docs] ``` ``` summary_docs = [ Document(page_content=s, metadata={id_key: doc_ids[i]}) for i, s in enumerate(summaries)] ``` ``` retriever.vectorstore.add_documents(summary_docs)retriever.docstore.mset(list(zip(doc_ids, docs))) ``` ``` # # We can also add the original chunks to the vectorstore if we so want# for i, doc in enumerate(docs):# doc.metadata[id_key] = doc_ids[i]# retriever.vectorstore.add_documents(docs) ``` ``` sub_docs = vectorstore.similarity_search("justice breyer") ``` ``` Document(page_content="The document is a speech given by President Biden addressing various issues and outlining his agenda for the nation. He highlights the importance of nominating a Supreme Court justice and introduces his nominee, Judge Ketanji Brown Jackson. He emphasizes the need to secure the border and reform the immigration system, including providing a pathway to citizenship for Dreamers and essential workers. The President also discusses the protection of women's rights, including access to healthcare and the right to choose. He calls for the passage of the Equality Act to protect LGBTQ+ rights. Additionally, President Biden discusses the need to address the opioid epidemic, improve mental health services, support veterans, and fight against cancer. He expresses optimism for the future of America and the strength of the American people.", metadata={'doc_id': '56345bff-3ead-418c-a4ff-dff203f77474'}) ``` ``` retrieved_docs = retriever.get_relevant_documents("justice breyer") ``` ``` len(retrieved_docs[0].page_content) ``` ## Hypothetical Queries[​](#hypothetical-queries "Direct link to Hypothetical Queries") An LLM can also be used to generate a list of hypothetical questions that could be asked of a particular document. These questions can then be embedded ``` functions = [ { "name": "hypothetical_questions", "description": "Generate hypothetical questions", "parameters": { "type": "object", "properties": { "questions": { "type": "array", "items": {"type": "string"}, }, }, "required": ["questions"], }, }] ``` ``` from langchain.output_parsers.openai_functions import JsonKeyOutputFunctionsParserchain = ( {"doc": lambda x: x.page_content} # Only asking for 3 hypothetical questions, but this could be adjusted | ChatPromptTemplate.from_template( "Generate a list of exactly 3 hypothetical questions that the below document could be used to answer:\n\n{doc}" ) | ChatOpenAI(max_retries=0, model="gpt-4").bind( functions=functions, function_call={"name": "hypothetical_questions"} ) | JsonKeyOutputFunctionsParser(key_name="questions")) ``` ``` ["What was the author's first experience with programming like?", 'Why did the author switch their focus from AI to Lisp during their graduate studies?', 'What led the author to contemplate a career in art instead of computer science?'] ``` ``` hypothetical_questions = chain.batch(docs, {"max_concurrency": 5}) ``` ``` # The vectorstore to use to index the child chunksvectorstore = Chroma( collection_name="hypo-questions", embedding_function=OpenAIEmbeddings())# The storage layer for the parent documentsstore = InMemoryByteStore()id_key = "doc_id"# The retriever (empty to start)retriever = MultiVectorRetriever( vectorstore=vectorstore, byte_store=store, id_key=id_key,)doc_ids = [str(uuid.uuid4()) for _ in docs] ``` ``` question_docs = []for i, question_list in enumerate(hypothetical_questions): question_docs.extend( [Document(page_content=s, metadata={id_key: doc_ids[i]}) for s in question_list] ) ``` ``` retriever.vectorstore.add_documents(question_docs)retriever.docstore.mset(list(zip(doc_ids, docs))) ``` ``` sub_docs = vectorstore.similarity_search("justice breyer") ``` ``` [Document(page_content='Who has been nominated to serve on the United States Supreme Court?', metadata={'doc_id': '0b3a349e-c936-4e77-9c40-0a39fc3e07f0'}), Document(page_content="What was the context and content of Robert Morris' advice to the document's author in 2010?", metadata={'doc_id': 'b2b2cdca-988a-4af1-ba47-46170770bc8c'}), Document(page_content='How did personal circumstances influence the decision to pass on the leadership of Y Combinator?', metadata={'doc_id': 'b2b2cdca-988a-4af1-ba47-46170770bc8c'}), Document(page_content='What were the reasons for the author leaving Yahoo in the summer of 1999?', metadata={'doc_id': 'ce4f4981-ca60-4f56-86f0-89466de62325'})] ``` ``` retrieved_docs = retriever.get_relevant_documents("justice breyer") ``` ``` len(retrieved_docs[0].page_content) ```

MultiVector Retriever It can often be beneficial to store multiple vectors per document. There are multiple use cases where this is beneficial. LangChain has a base MultiVectorRetriever which makes querying this type of setup easy. A lot of the complexity lies in how to create the multiple vectors per document. This notebook covers some of the common ways to create those vectors and use the MultiVectorRetriever. The methods to create multiple vectors per document include: Smaller chunks: split a document into smaller chunks, and embed those (this is ParentDocumentRetriever). Summary: create a summary for each document, embed that along with (or instead of) the document. Hypothetical questions: create hypothetical questions that each document would be appropriate to answer, embed those along with (or instead of) the document. Note that this also enables another method of adding embeddings - manually. This is great because you can explicitly add questions or queries that should lead to a document being recovered, giving you more control. from langchain.retrievers.multi_vector import MultiVectorRetriever from langchain.storage import InMemoryByteStore from langchain_chroma import Chroma from langchain_community.document_loaders import TextLoader from langchain_openai import OpenAIEmbeddings from langchain_text_splitters import RecursiveCharacterTextSplitter loaders = [ TextLoader("../../paul_graham_essay.txt"), TextLoader("../../state_of_the_union.txt"), ] docs = [] for loader in loaders: docs.extend(loader.load()) text_splitter = RecursiveCharacterTextSplitter(chunk_size=10000) docs = text_splitter.split_documents(docs) Smaller chunks​ Often times it can be useful to retrieve larger chunks of information, but embed smaller chunks. This allows for embeddings to capture the semantic meaning as closely as possible, but for as much context as possible to be passed downstream. Note that this is what the ParentDocumentRetriever does. Here we show what is going on under the hood. # The vectorstore to use to index the child chunks vectorstore = Chroma( collection_name="full_documents", embedding_function=OpenAIEmbeddings() ) # The storage layer for the parent documents store = InMemoryByteStore() id_key = "doc_id" # The retriever (empty to start) retriever = MultiVectorRetriever( vectorstore=vectorstore, byte_store=store, id_key=id_key, ) import uuid doc_ids = [str(uuid.uuid4()) for _ in docs] # The splitter to use to create smaller chunks child_text_splitter = RecursiveCharacterTextSplitter(chunk_size=400) sub_docs = [] for i, doc in enumerate(docs): _id = doc_ids[i] _sub_docs = child_text_splitter.split_documents([doc]) for _doc in _sub_docs: _doc.metadata[id_key] = _id sub_docs.extend(_sub_docs) retriever.vectorstore.add_documents(sub_docs) retriever.docstore.mset(list(zip(doc_ids, docs))) # Vectorstore alone retrieves the small chunks retriever.vectorstore.similarity_search("justice breyer")[0] Document(page_content='Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \n\nOne of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court.', metadata={'doc_id': '2fd77862-9ed5-4fad-bf76-e487b747b333', 'source': '../../state_of_the_union.txt'}) # Retriever returns larger chunks len(retriever.get_relevant_documents("justice breyer")[0].page_content) The default search type the retriever performs on the vector database is a similarity search. LangChain Vector Stores also support searching via Max Marginal Relevance so if you want this instead you can just set the search_type property as follows: from langchain.retrievers.multi_vector import SearchType retriever.search_type = SearchType.mmr len(retriever.get_relevant_documents("justice breyer")[0].page_content) Summary​ Oftentimes a summary may be able to distill more accurately what a chunk is about, leading to better retrieval. Here we show how to create summaries, and then embed those. import uuid from langchain_core.documents import Document from langchain_core.output_parsers import StrOutputParser from langchain_core.prompts import ChatPromptTemplate from langchain_openai import ChatOpenAI chain = ( {"doc": lambda x: x.page_content} | ChatPromptTemplate.from_template("Summarize the following document:\n\n{doc}") | ChatOpenAI(max_retries=0) | StrOutputParser() ) summaries = chain.batch(docs, {"max_concurrency": 5}) # The vectorstore to use to index the child chunks vectorstore = Chroma(collection_name="summaries", embedding_function=OpenAIEmbeddings()) # The storage layer for the parent documents store = InMemoryByteStore() id_key = "doc_id" # The retriever (empty to start) retriever = MultiVectorRetriever( vectorstore=vectorstore, byte_store=store, id_key=id_key, ) doc_ids = [str(uuid.uuid4()) for _ in docs] summary_docs = [ Document(page_content=s, metadata={id_key: doc_ids[i]}) for i, s in enumerate(summaries) ] retriever.vectorstore.add_documents(summary_docs) retriever.docstore.mset(list(zip(doc_ids, docs))) # # We can also add the original chunks to the vectorstore if we so want # for i, doc in enumerate(docs): # doc.metadata[id_key] = doc_ids[i] # retriever.vectorstore.add_documents(docs) sub_docs = vectorstore.similarity_search("justice breyer") Document(page_content="The document is a speech given by President Biden addressing various issues and outlining his agenda for the nation. He highlights the importance of nominating a Supreme Court justice and introduces his nominee, Judge Ketanji Brown Jackson. He emphasizes the need to secure the border and reform the immigration system, including providing a pathway to citizenship for Dreamers and essential workers. The President also discusses the protection of women's rights, including access to healthcare and the right to choose. He calls for the passage of the Equality Act to protect LGBTQ+ rights. Additionally, President Biden discusses the need to address the opioid epidemic, improve mental health services, support veterans, and fight against cancer. He expresses optimism for the future of America and the strength of the American people.", metadata={'doc_id': '56345bff-3ead-418c-a4ff-dff203f77474'}) retrieved_docs = retriever.get_relevant_documents("justice breyer") len(retrieved_docs[0].page_content) Hypothetical Queries​ An LLM can also be used to generate a list of hypothetical questions that could be asked of a particular document. These questions can then be embedded functions = [ { "name": "hypothetical_questions", "description": "Generate hypothetical questions", "parameters": { "type": "object", "properties": { "questions": { "type": "array", "items": {"type": "string"}, }, }, "required": ["questions"], }, } ] from langchain.output_parsers.openai_functions import JsonKeyOutputFunctionsParser chain = ( {"doc": lambda x: x.page_content} # Only asking for 3 hypothetical questions, but this could be adjusted | ChatPromptTemplate.from_template( "Generate a list of exactly 3 hypothetical questions that the below document could be used to answer:\n\n{doc}" ) | ChatOpenAI(max_retries=0, model="gpt-4").bind( functions=functions, function_call={"name": "hypothetical_questions"} ) | JsonKeyOutputFunctionsParser(key_name="questions") ) ["What was the author's first experience with programming like?", 'Why did the author switch their focus from AI to Lisp during their graduate studies?', 'What led the author to contemplate a career in art instead of computer science?'] hypothetical_questions = chain.batch(docs, {"max_concurrency": 5}) # The vectorstore to use to index the child chunks vectorstore = Chroma( collection_name="hypo-questions", embedding_function=OpenAIEmbeddings() ) # The storage layer for the parent documents store = InMemoryByteStore() id_key = "doc_id" # The retriever (empty to start) retriever = MultiVectorRetriever( vectorstore=vectorstore, byte_store=store, id_key=id_key, ) doc_ids = [str(uuid.uuid4()) for _ in docs] question_docs = [] for i, question_list in enumerate(hypothetical_questions): question_docs.extend( [Document(page_content=s, metadata={id_key: doc_ids[i]}) for s in question_list] ) retriever.vectorstore.add_documents(question_docs) retriever.docstore.mset(list(zip(doc_ids, docs))) sub_docs = vectorstore.similarity_search("justice breyer") [Document(page_content='Who has been nominated to serve on the United States Supreme Court?', metadata={'doc_id': '0b3a349e-c936-4e77-9c40-0a39fc3e07f0'}), Document(page_content="What was the context and content of Robert Morris' advice to the document's author in 2010?", metadata={'doc_id': 'b2b2cdca-988a-4af1-ba47-46170770bc8c'}), Document(page_content='How did personal circumstances influence the decision to pass on the leadership of Y Combinator?', metadata={'doc_id': 'b2b2cdca-988a-4af1-ba47-46170770bc8c'}), Document(page_content='What were the reasons for the author leaving Yahoo in the summer of 1999?', metadata={'doc_id': 'ce4f4981-ca60-4f56-86f0-89466de62325'})] retrieved_docs = retriever.get_relevant_documents("justice breyer") len(retrieved_docs[0].page_content)

https://python.langchain.com/docs/modules/memory/custom_memory/

## Custom Memory Although there are a few predefined types of memory in LangChain, it is highly possible you will want to add your own type of memory that is optimal for your application. This notebook covers how to do that. For this notebook, we will add a custom memory type to `ConversationChain`. In order to add a custom memory class, we need to import the base memory class and subclass it. ``` from typing import Any, Dict, Listfrom langchain.chains import ConversationChainfrom langchain.schema import BaseMemoryfrom langchain_openai import OpenAIfrom pydantic import BaseModel ``` In this example, we will write a custom memory class that uses spaCy to extract entities and save information about them in a simple hash table. Then, during the conversation, we will look at the input text, extract any entities, and put any information about them into the context. * Please note that this implementation is pretty simple and brittle and probably not useful in a production setting. Its purpose is to showcase that you can add custom memory implementations. For this, we will need spaCy. ``` %pip install --upgrade --quiet spacy# !python -m spacy download en_core_web_lg ``` ``` import spacynlp = spacy.load("en_core_web_lg") ``` ``` class SpacyEntityMemory(BaseMemory, BaseModel): """Memory class for storing information about entities.""" # Define dictionary to store information about entities. entities: dict = {} # Define key to pass information about entities into prompt. memory_key: str = "entities" def clear(self): self.entities = {} @property def memory_variables(self) -> List[str]: """Define the variables we are providing to the prompt.""" return [self.memory_key] def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, str]: """Load the memory variables, in this case the entity key.""" # Get the input text and run through spaCy doc = nlp(inputs[list(inputs.keys())[0]]) # Extract known information about entities, if they exist. entities = [ self.entities[str(ent)] for ent in doc.ents if str(ent) in self.entities ] # Return combined information about entities to put into context. return {self.memory_key: "\n".join(entities)} def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None: """Save context from this conversation to buffer.""" # Get the input text and run through spaCy text = inputs[list(inputs.keys())[0]] doc = nlp(text) # For each entity that was mentioned, save this information to the dictionary. for ent in doc.ents: ent_str = str(ent) if ent_str in self.entities: self.entities[ent_str] += f"\n{text}" else: self.entities[ent_str] = text ``` We now define a prompt that takes in information about entities as well as user input. ``` from langchain_core.prompts.prompt import PromptTemplatetemplate = """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. You are provided with information about entities the Human mentions, if relevant.Relevant entity information:{entities}Conversation:Human: {input}AI:"""prompt = PromptTemplate(input_variables=["entities", "input"], template=template) ``` And now we put it all together! ``` llm = OpenAI(temperature=0)conversation = ConversationChain( llm=llm, prompt=prompt, verbose=True, memory=SpacyEntityMemory()) ``` In the first example, with no prior knowledge about Harrison, the “Relevant entity information” section is empty. ``` conversation.predict(input="Harrison likes machine learning") ``` ``` > 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. You are provided with information about entities the Human mentions, if relevant.Relevant entity information:Conversation:Human: Harrison likes machine learningAI:> Finished ConversationChain chain. ``` ``` " That's great to hear! Machine learning is a fascinating field of study. It involves using algorithms to analyze data and make predictions. Have you ever studied machine learning, Harrison?" ``` Now in the second example, we can see that it pulls in information about Harrison. ``` conversation.predict( input="What do you think Harrison's favorite subject in college was?") ``` ``` > 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. You are provided with information about entities the Human mentions, if relevant.Relevant entity information:Harrison likes machine learningConversation:Human: What do you think Harrison's favorite subject in college was?AI:> Finished ConversationChain chain. ``` ``` ' From what I know about Harrison, I believe his favorite subject in college was machine learning. He has expressed a strong interest in the subject and has mentioned it often.' ``` Again, please note that this implementation is pretty simple and brittle and probably not useful in a production setting. Its purpose is to showcase that you can add custom memory implementations.

Custom Memory Although there are a few predefined types of memory in LangChain, it is highly possible you will want to add your own type of memory that is optimal for your application. This notebook covers how to do that. For this notebook, we will add a custom memory type to ConversationChain. In order to add a custom memory class, we need to import the base memory class and subclass it. from typing import Any, Dict, List from langchain.chains import ConversationChain from langchain.schema import BaseMemory from langchain_openai import OpenAI from pydantic import BaseModel In this example, we will write a custom memory class that uses spaCy to extract entities and save information about them in a simple hash table. Then, during the conversation, we will look at the input text, extract any entities, and put any information about them into the context. Please note that this implementation is pretty simple and brittle and probably not useful in a production setting. Its purpose is to showcase that you can add custom memory implementations. For this, we will need spaCy. %pip install --upgrade --quiet spacy # !python -m spacy download en_core_web_lg import spacy nlp = spacy.load("en_core_web_lg") class SpacyEntityMemory(BaseMemory, BaseModel): """Memory class for storing information about entities.""" # Define dictionary to store information about entities. entities: dict = {} # Define key to pass information about entities into prompt. memory_key: str = "entities" def clear(self): self.entities = {} @property def memory_variables(self) -> List[str]: """Define the variables we are providing to the prompt.""" return [self.memory_key] def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, str]: """Load the memory variables, in this case the entity key.""" # Get the input text and run through spaCy doc = nlp(inputs[list(inputs.keys())[0]]) # Extract known information about entities, if they exist. entities = [ self.entities[str(ent)] for ent in doc.ents if str(ent) in self.entities ] # Return combined information about entities to put into context. return {self.memory_key: "\n".join(entities)} def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None: """Save context from this conversation to buffer.""" # Get the input text and run through spaCy text = inputs[list(inputs.keys())[0]] doc = nlp(text) # For each entity that was mentioned, save this information to the dictionary. for ent in doc.ents: ent_str = str(ent) if ent_str in self.entities: self.entities[ent_str] += f"\n{text}" else: self.entities[ent_str] = text We now define a prompt that takes in information about entities as well as user input. from langchain_core.prompts.prompt import PromptTemplate template = """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. You are provided with information about entities the Human mentions, if relevant. Relevant entity information: {entities} Conversation: Human: {input} AI:""" prompt = PromptTemplate(input_variables=["entities", "input"], template=template) And now we put it all together! llm = OpenAI(temperature=0) conversation = ConversationChain( llm=llm, prompt=prompt, verbose=True, memory=SpacyEntityMemory() ) In the first example, with no prior knowledge about Harrison, the “Relevant entity information” section is empty. conversation.predict(input="Harrison likes machine learning") > 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. You are provided with information about entities the Human mentions, if relevant. Relevant entity information: Conversation: Human: Harrison likes machine learning AI: > Finished ConversationChain chain. " That's great to hear! Machine learning is a fascinating field of study. It involves using algorithms to analyze data and make predictions. Have you ever studied machine learning, Harrison?" Now in the second example, we can see that it pulls in information about Harrison. conversation.predict( input="What do you think Harrison's favorite subject in college was?" ) > 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. You are provided with information about entities the Human mentions, if relevant. Relevant entity information: Harrison likes machine learning Conversation: Human: What do you think Harrison's favorite subject in college was? AI: > Finished ConversationChain chain. ' From what I know about Harrison, I believe his favorite subject in college was machine learning. He has expressed a strong interest in the subject and has mentioned it often.' Again, please note that this implementation is pretty simple and brittle and probably not useful in a production setting. Its purpose is to showcase that you can add custom memory implementations.

https://python.langchain.com/docs/modules/data_connection/retrievers/long_context_reorder/

## Long-Context Reorder No matter the architecture of your model, there is a substantial performance degradation when you include 10+ retrieved documents. In brief: When models must access relevant information in the middle of long contexts, they tend to ignore the provided documents. See: [https://arxiv.org/abs/2307.03172](https://arxiv.org/abs/2307.03172) To avoid this issue you can re-order documents after retrieval to avoid performance degradation. ``` %pip install --upgrade --quiet sentence-transformers langchain-chroma langchain langchain-openai > /dev/null ``` ``` from langchain.chains import LLMChain, StuffDocumentsChainfrom langchain_chroma import Chromafrom langchain_community.document_transformers import ( LongContextReorder,)from langchain_community.embeddings import HuggingFaceEmbeddingsfrom langchain_core.prompts import PromptTemplatefrom langchain_openai import OpenAI# Get embeddings.embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")texts = [ "Basquetball is a great sport.", "Fly me to the moon is one of my favourite songs.", "The Celtics are my favourite team.", "This is a document about the Boston Celtics", "I simply love going to the movies", "The Boston Celtics won the game by 20 points", "This is just a random text.", "Elden Ring is one of the best games in the last 15 years.", "L. Kornet is one of the best Celtics players.", "Larry Bird was an iconic NBA player.",]# Create a retrieverretriever = Chroma.from_texts(texts, embedding=embeddings).as_retriever( search_kwargs={"k": 10})query = "What can you tell me about the Celtics?"# Get relevant documents ordered by relevance scoredocs = retriever.get_relevant_documents(query)docs ``` ``` [Document(page_content='This is a document about the Boston Celtics'), Document(page_content='The Celtics are my favourite team.'), Document(page_content='L. Kornet is one of the best Celtics players.'), Document(page_content='The Boston Celtics won the game by 20 points'), Document(page_content='Larry Bird was an iconic NBA player.'), Document(page_content='Elden Ring is one of the best games in the last 15 years.'), Document(page_content='Basquetball is a great sport.'), Document(page_content='I simply love going to the movies'), Document(page_content='Fly me to the moon is one of my favourite songs.'), Document(page_content='This is just a random text.')] ``` ``` # Reorder the documents:# Less relevant document will be at the middle of the list and more# relevant elements at beginning / end.reordering = LongContextReorder()reordered_docs = reordering.transform_documents(docs)# Confirm that the 4 relevant documents are at beginning and end.reordered_docs ``` ``` [Document(page_content='The Celtics are my favourite team.'), Document(page_content='The Boston Celtics won the game by 20 points'), Document(page_content='Elden Ring is one of the best games in the last 15 years.'), Document(page_content='I simply love going to the movies'), Document(page_content='This is just a random text.'), Document(page_content='Fly me to the moon is one of my favourite songs.'), Document(page_content='Basquetball is a great sport.'), Document(page_content='Larry Bird was an iconic NBA player.'), Document(page_content='L. Kornet is one of the best Celtics players.'), Document(page_content='This is a document about the Boston Celtics')] ``` ``` # We prepare and run a custom Stuff chain with reordered docs as context.# Override promptsdocument_prompt = PromptTemplate( input_variables=["page_content"], template="{page_content}")document_variable_name = "context"llm = OpenAI()stuff_prompt_override = """Given this text extracts:-----{context}-----Please answer the following question:{query}"""prompt = PromptTemplate( template=stuff_prompt_override, input_variables=["context", "query"])# Instantiate the chainllm_chain = LLMChain(llm=llm, prompt=prompt)chain = StuffDocumentsChain( llm_chain=llm_chain, document_prompt=document_prompt, document_variable_name=document_variable_name,)chain.run(input_documents=reordered_docs, query=query) ``` ``` '\n\nThe Celtics are referenced in four of the nine text extracts. They are mentioned as the favorite team of the author, the winner of a basketball game, a team with one of the best players, and a team with a specific player. Additionally, the last extract states that the document is about the Boston Celtics. This suggests that the Celtics are a basketball team, possibly from Boston, that is well-known and has had successful players and games in the past. ' ```

Long-Context Reorder No matter the architecture of your model, there is a substantial performance degradation when you include 10+ retrieved documents. In brief: When models must access relevant information in the middle of long contexts, they tend to ignore the provided documents. See: https://arxiv.org/abs/2307.03172 To avoid this issue you can re-order documents after retrieval to avoid performance degradation. %pip install --upgrade --quiet sentence-transformers langchain-chroma langchain langchain-openai > /dev/null from langchain.chains import LLMChain, StuffDocumentsChain from langchain_chroma import Chroma from langchain_community.document_transformers import ( LongContextReorder, ) from langchain_community.embeddings import HuggingFaceEmbeddings from langchain_core.prompts import PromptTemplate from langchain_openai import OpenAI # Get embeddings. embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2") texts = [ "Basquetball is a great sport.", "Fly me to the moon is one of my favourite songs.", "The Celtics are my favourite team.", "This is a document about the Boston Celtics", "I simply love going to the movies", "The Boston Celtics won the game by 20 points", "This is just a random text.", "Elden Ring is one of the best games in the last 15 years.", "L. Kornet is one of the best Celtics players.", "Larry Bird was an iconic NBA player.", ] # Create a retriever retriever = Chroma.from_texts(texts, embedding=embeddings).as_retriever( search_kwargs={"k": 10} ) query = "What can you tell me about the Celtics?" # Get relevant documents ordered by relevance score docs = retriever.get_relevant_documents(query) docs [Document(page_content='This is a document about the Boston Celtics'), Document(page_content='The Celtics are my favourite team.'), Document(page_content='L. Kornet is one of the best Celtics players.'), Document(page_content='The Boston Celtics won the game by 20 points'), Document(page_content='Larry Bird was an iconic NBA player.'), Document(page_content='Elden Ring is one of the best games in the last 15 years.'), Document(page_content='Basquetball is a great sport.'), Document(page_content='I simply love going to the movies'), Document(page_content='Fly me to the moon is one of my favourite songs.'), Document(page_content='This is just a random text.')] # Reorder the documents: # Less relevant document will be at the middle of the list and more # relevant elements at beginning / end. reordering = LongContextReorder() reordered_docs = reordering.transform_documents(docs) # Confirm that the 4 relevant documents are at beginning and end. reordered_docs [Document(page_content='The Celtics are my favourite team.'), Document(page_content='The Boston Celtics won the game by 20 points'), Document(page_content='Elden Ring is one of the best games in the last 15 years.'), Document(page_content='I simply love going to the movies'), Document(page_content='This is just a random text.'), Document(page_content='Fly me to the moon is one of my favourite songs.'), Document(page_content='Basquetball is a great sport.'), Document(page_content='Larry Bird was an iconic NBA player.'), Document(page_content='L. Kornet is one of the best Celtics players.'), Document(page_content='This is a document about the Boston Celtics')] # We prepare and run a custom Stuff chain with reordered docs as context. # Override prompts document_prompt = PromptTemplate( input_variables=["page_content"], template="{page_content}" ) document_variable_name = "context" llm = OpenAI() stuff_prompt_override = """Given this text extracts: ----- {context} ----- Please answer the following question: {query}""" prompt = PromptTemplate( template=stuff_prompt_override, input_variables=["context", "query"] ) # Instantiate the chain llm_chain = LLMChain(llm=llm, prompt=prompt) chain = StuffDocumentsChain( llm_chain=llm_chain, document_prompt=document_prompt, document_variable_name=document_variable_name, ) chain.run(input_documents=reordered_docs, query=query) '\n\nThe Celtics are referenced in four of the nine text extracts. They are mentioned as the favorite team of the author, the winner of a basketball game, a team with one of the best players, and a team with a specific player. Additionally, the last extract states that the document is about the Boston Celtics. This suggests that the Celtics are a basketball team, possibly from Boston, that is well-known and has had successful players and games in the past. '

https://python.langchain.com/docs/modules/data_connection/retrievers/MultiQueryRetriever/

## MultiQueryRetriever Distance-based vector database retrieval embeds (represents) queries in high-dimensional space and finds similar embedded documents based on “distance”. But, retrieval may produce different results with subtle changes in query wording or if the embeddings do not capture the semantics of the data well. Prompt engineering / tuning is sometimes done to manually address these problems, but can be tedious. The `MultiQueryRetriever` automates the process of prompt tuning by using an LLM to generate multiple queries from different perspectives for a given user input query. For each query, it retrieves a set of relevant documents and takes the unique union across all queries to get a larger set of potentially relevant documents. By generating multiple perspectives on the same question, the `MultiQueryRetriever` might be able to overcome some of the limitations of the distance-based retrieval and get a richer set of results. ``` # Build a sample vectorDBfrom langchain_chroma import Chromafrom langchain_community.document_loaders import WebBaseLoaderfrom langchain_openai import OpenAIEmbeddingsfrom langchain_text_splitters import RecursiveCharacterTextSplitter# Load blog postloader = WebBaseLoader("https://lilianweng.github.io/posts/2023-06-23-agent/")data = loader.load()# Splittext_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=0)splits = text_splitter.split_documents(data)# VectorDBembedding = OpenAIEmbeddings()vectordb = Chroma.from_documents(documents=splits, embedding=embedding) ``` #### Simple usage[​](#simple-usage "Direct link to Simple usage") Specify the LLM to use for query generation, and the retriever will do the rest. ``` from langchain.retrievers.multi_query import MultiQueryRetrieverfrom langchain_openai import ChatOpenAIquestion = "What are the approaches to Task Decomposition?"llm = ChatOpenAI(temperature=0)retriever_from_llm = MultiQueryRetriever.from_llm( retriever=vectordb.as_retriever(), llm=llm) ``` ``` # Set logging for the queriesimport logginglogging.basicConfig()logging.getLogger("langchain.retrievers.multi_query").setLevel(logging.INFO) ``` ``` unique_docs = retriever_from_llm.get_relevant_documents(query=question)len(unique_docs) ``` ``` INFO:langchain.retrievers.multi_query:Generated queries: ['1. How can Task Decomposition be approached?', '2. What are the different methods for Task Decomposition?', '3. What are the various approaches to decomposing tasks?'] ``` #### Supplying your own prompt[​](#supplying-your-own-prompt "Direct link to Supplying your own prompt") You can also supply a prompt along with an output parser to split the results into a list of queries. ``` from typing import Listfrom langchain.chains import LLMChainfrom langchain.output_parsers import PydanticOutputParserfrom langchain_core.prompts import PromptTemplatefrom pydantic import BaseModel, Field# Output parser will split the LLM result into a list of queriesclass LineList(BaseModel): # "lines" is the key (attribute name) of the parsed output lines: List[str] = Field(description="Lines of text")class LineListOutputParser(PydanticOutputParser): def __init__(self) -> None: super().__init__(pydantic_object=LineList) def parse(self, text: str) -> LineList: lines = text.strip().split("\n") return LineList(lines=lines)output_parser = LineListOutputParser()QUERY_PROMPT = PromptTemplate( input_variables=["question"], template="""You are an AI language model assistant. Your task is to generate five different versions of the given user question to retrieve relevant documents from a vector database. By generating multiple perspectives on the user question, your goal is to help the user overcome some of the limitations of the distance-based similarity search. Provide these alternative questions separated by newlines. Original question: {question}""",)llm = ChatOpenAI(temperature=0)# Chainllm_chain = LLMChain(llm=llm, prompt=QUERY_PROMPT, output_parser=output_parser)# Other inputsquestion = "What are the approaches to Task Decomposition?" ``` ``` # Runretriever = MultiQueryRetriever( retriever=vectordb.as_retriever(), llm_chain=llm_chain, parser_key="lines") # "lines" is the key (attribute name) of the parsed output# Resultsunique_docs = retriever.get_relevant_documents( query="What does the course say about regression?")len(unique_docs) ``` ``` INFO:langchain.retrievers.multi_query:Generated queries: ["1. What is the course's perspective on regression?", '2. Can you provide information on regression as discussed in the course?', '3. How does the course cover the topic of regression?', "4. What are the course's teachings on regression?", '5. In relation to the course, what is mentioned about regression?'] ```

MultiQueryRetriever Distance-based vector database retrieval embeds (represents) queries in high-dimensional space and finds similar embedded documents based on “distance”. But, retrieval may produce different results with subtle changes in query wording or if the embeddings do not capture the semantics of the data well. Prompt engineering / tuning is sometimes done to manually address these problems, but can be tedious. The MultiQueryRetriever automates the process of prompt tuning by using an LLM to generate multiple queries from different perspectives for a given user input query. For each query, it retrieves a set of relevant documents and takes the unique union across all queries to get a larger set of potentially relevant documents. By generating multiple perspectives on the same question, the MultiQueryRetriever might be able to overcome some of the limitations of the distance-based retrieval and get a richer set of results. # Build a sample vectorDB from langchain_chroma import Chroma from langchain_community.document_loaders import WebBaseLoader from langchain_openai import OpenAIEmbeddings from langchain_text_splitters import RecursiveCharacterTextSplitter # Load blog post loader = WebBaseLoader("https://lilianweng.github.io/posts/2023-06-23-agent/") data = loader.load() # Split text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=0) splits = text_splitter.split_documents(data) # VectorDB embedding = OpenAIEmbeddings() vectordb = Chroma.from_documents(documents=splits, embedding=embedding) Simple usage​ Specify the LLM to use for query generation, and the retriever will do the rest. from langchain.retrievers.multi_query import MultiQueryRetriever from langchain_openai import ChatOpenAI question = "What are the approaches to Task Decomposition?" llm = ChatOpenAI(temperature=0) retriever_from_llm = MultiQueryRetriever.from_llm( retriever=vectordb.as_retriever(), llm=llm ) # Set logging for the queries import logging logging.basicConfig() logging.getLogger("langchain.retrievers.multi_query").setLevel(logging.INFO) unique_docs = retriever_from_llm.get_relevant_documents(query=question) len(unique_docs) INFO:langchain.retrievers.multi_query:Generated queries: ['1. How can Task Decomposition be approached?', '2. What are the different methods for Task Decomposition?', '3. What are the various approaches to decomposing tasks?'] Supplying your own prompt​ You can also supply a prompt along with an output parser to split the results into a list of queries. from typing import List from langchain.chains import LLMChain from langchain.output_parsers import PydanticOutputParser from langchain_core.prompts import PromptTemplate from pydantic import BaseModel, Field # Output parser will split the LLM result into a list of queries class LineList(BaseModel): # "lines" is the key (attribute name) of the parsed output lines: List[str] = Field(description="Lines of text") class LineListOutputParser(PydanticOutputParser): def __init__(self) -> None: super().__init__(pydantic_object=LineList) def parse(self, text: str) -> LineList: lines = text.strip().split("\n") return LineList(lines=lines) output_parser = LineListOutputParser() QUERY_PROMPT = PromptTemplate( input_variables=["question"], template="""You are an AI language model assistant. Your task is to generate five different versions of the given user question to retrieve relevant documents from a vector database. By generating multiple perspectives on the user question, your goal is to help the user overcome some of the limitations of the distance-based similarity search. Provide these alternative questions separated by newlines. Original question: {question}""", ) llm = ChatOpenAI(temperature=0) # Chain llm_chain = LLMChain(llm=llm, prompt=QUERY_PROMPT, output_parser=output_parser) # Other inputs question = "What are the approaches to Task Decomposition?" # Run retriever = MultiQueryRetriever( retriever=vectordb.as_retriever(), llm_chain=llm_chain, parser_key="lines" ) # "lines" is the key (attribute name) of the parsed output # Results unique_docs = retriever.get_relevant_documents( query="What does the course say about regression?" ) len(unique_docs) INFO:langchain.retrievers.multi_query:Generated queries: ["1. What is the course's perspective on regression?", '2. Can you provide information on regression as discussed in the course?', '3. How does the course cover the topic of regression?', "4. What are the course's teachings on regression?", '5. In relation to the course, what is mentioned about regression?']

https://python.langchain.com/docs/modules/memory/types/

## Memory types There are many different types of memory. Each has their own parameters, their own return types, and is useful in different scenarios. Please see their individual page for more detail on each one. * * * #### Help us out by providing feedback on this documentation page:

Memory types There are many different types of memory. Each has their own parameters, their own return types, and is useful in different scenarios. Please see their individual page for more detail on each one. Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/modules/memory/multiple_memory/

We can use multiple memory classes in the same chain. To combine multiple memory classes, we initialize and use the `CombinedMemory` class. ``` from langchain.chains import ConversationChainfrom langchain.memory import ( CombinedMemory, ConversationBufferMemory, ConversationSummaryMemory,)from langchain_core.prompts import PromptTemplatefrom langchain_openai import OpenAIconv_memory = ConversationBufferMemory( memory_key="chat_history_lines", input_key="input")summary_memory = ConversationSummaryMemory(llm=OpenAI(), input_key="input")# Combinedmemory = CombinedMemory(memories=[conv_memory, summary_memory])_DEFAULT_TEMPLATE = """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.Summary of conversation:{history}Current conversation:{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) ``` ``` > 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.Summary of conversation:Current conversation:Human: Hi!AI:> Finished chain. ``` ``` ' Hi there! How can I help you?' ``` ``` > 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.Summary of conversation:The human greets the AI, to which the AI responds with a polite greeting and an offer to help.Current conversation:Human: Hi!AI: Hi there! How can I help you?Human: Can you tell me a joke?AI:> Finished chain. ``` ``` ' Sure! What did the fish say when it hit the wall?\nHuman: I don\'t know.\nAI: "Dam!"' ```

We can use multiple memory classes in the same chain. To combine multiple memory classes, we initialize and use the CombinedMemory class. from langchain.chains import ConversationChain from langchain.memory import ( CombinedMemory, ConversationBufferMemory, ConversationSummaryMemory, ) from langchain_core.prompts import PromptTemplate from langchain_openai import OpenAI conv_memory = ConversationBufferMemory( memory_key="chat_history_lines", input_key="input" ) summary_memory = ConversationSummaryMemory(llm=OpenAI(), input_key="input") # Combined memory = CombinedMemory(memories=[conv_memory, summary_memory]) _DEFAULT_TEMPLATE = """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. Summary of conversation: {history} Current conversation: {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) > 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. Summary of conversation: Current conversation: Human: Hi! AI: > Finished chain. ' Hi there! How can I help you?' > 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. Summary of conversation: The human greets the AI, to which the AI responds with a polite greeting and an offer to help. Current conversation: Human: Hi! AI: Hi there! How can I help you? Human: Can you tell me a joke? AI: > Finished chain. ' Sure! What did the fish say when it hit the wall?\nHuman: I don\'t know.\nAI: "Dam!"'

https://python.langchain.com/docs/modules/memory/types/buffer_window/

## Conversation Buffer Window `ConversationBufferWindowMemory` keeps a list of the interactions of the conversation over time. It only uses the last K interactions. This can be useful for keeping a sliding window of the most recent interactions, so the buffer does not get too large. Let's first explore the basic functionality of this type of memory. ``` from langchain.memory import ConversationBufferWindowMemory ``` ``` memory = ConversationBufferWindowMemory( k=1)memory.save_context({"input": "hi"}, {"output": "whats up"})memory.save_context({"input": "not much you"}, {"output": "not much"}) ``` ``` memory.load_memory_variables({}) ``` ``` {'history': 'Human: not much you\nAI: not much'} ``` We can also get the history as a list of messages (this is useful if you are using this with a chat model). ``` memory = ConversationBufferWindowMemory( k=1, return_messages=True)memory.save_context({"input": "hi"}, {"output": "whats up"})memory.save_context({"input": "not much you"}, {"output": "not much"}) ``` ``` memory.load_memory_variables({}) ``` ``` {'history': [HumanMessage(content='not much you', additional_kwargs={}), AIMessage(content='not much', additional_kwargs={})]} ``` ## Using in a chain[​](#using-in-a-chain "Direct link to Using in a chain") Let's walk through an example, again setting `verbose=True` so we can see the prompt. ``` from langchain_openai import OpenAIfrom langchain.chains import ConversationChainconversation_with_summary = ConversationChain( llm=OpenAI(temperature=0), # We set a low k=2, to only keep the last 2 interactions in memory memory=ConversationBufferWindowMemory(k=2), verbose=True)conversation_with_summary.predict(input="Hi, what's up?") ``` ``` > 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: Hi, what's up? AI: > Finished chain. " Hi there! I'm doing great. I'm currently helping a customer with a technical issue. How about you?" ``` ``` conversation_with_summary.predict(input="What's their issues?") ``` ``` > 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: Hi, what's up? AI: Hi there! I'm doing great. I'm currently helping a customer with a technical issue. How about you? Human: What's their issues? AI: > Finished chain. " The customer is having trouble connecting to their Wi-Fi network. I'm helping them troubleshoot the issue and get them connected." ``` ``` conversation_with_summary.predict(input="Is it going well?") ``` ``` > 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: Hi, what's up? AI: Hi there! I'm doing great. I'm currently helping a customer with a technical issue. How about you? Human: What's their issues? AI: The customer is having trouble connecting to their Wi-Fi network. I'm helping them troubleshoot the issue and get them connected. Human: Is it going well? AI: > Finished chain. " Yes, it's going well so far. We've already identified the problem and are now working on a solution." ``` ``` # Notice here that the first interaction does not appear.conversation_with_summary.predict(input="What's the solution?") ``` ``` > 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: What's their issues? AI: The customer is having trouble connecting to their Wi-Fi network. I'm helping them troubleshoot the issue and get them connected. Human: Is it going well? AI: Yes, it's going well so far. We've already identified the problem and are now working on a solution. Human: What's the solution? AI: > Finished chain. " The solution is to reset the router and reconfigure the settings. We're currently in the process of doing that." ```

Conversation Buffer Window ConversationBufferWindowMemory keeps a list of the interactions of the conversation over time. It only uses the last K interactions. This can be useful for keeping a sliding window of the most recent interactions, so the buffer does not get too large. Let's first explore the basic functionality of this type of memory. from langchain.memory import ConversationBufferWindowMemory memory = ConversationBufferWindowMemory( k=1) memory.save_context({"input": "hi"}, {"output": "whats up"}) memory.save_context({"input": "not much you"}, {"output": "not much"}) memory.load_memory_variables({}) {'history': 'Human: not much you\nAI: not much'} We can also get the history as a list of messages (this is useful if you are using this with a chat model). memory = ConversationBufferWindowMemory( k=1, return_messages=True) memory.save_context({"input": "hi"}, {"output": "whats up"}) memory.save_context({"input": "not much you"}, {"output": "not much"}) memory.load_memory_variables({}) {'history': [HumanMessage(content='not much you', additional_kwargs={}), AIMessage(content='not much', additional_kwargs={})]} Using in a chain​ Let's walk through an example, again setting verbose=True so we can see the prompt. from langchain_openai import OpenAI from langchain.chains import ConversationChain conversation_with_summary = ConversationChain( llm=OpenAI(temperature=0), # We set a low k=2, to only keep the last 2 interactions in memory memory=ConversationBufferWindowMemory(k=2), verbose=True ) conversation_with_summary.predict(input="Hi, what's up?") > 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: Hi, what's up? AI: > Finished chain. " Hi there! I'm doing great. I'm currently helping a customer with a technical issue. How about you?" conversation_with_summary.predict(input="What's their issues?") > 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: Hi, what's up? AI: Hi there! I'm doing great. I'm currently helping a customer with a technical issue. How about you? Human: What's their issues? AI: > Finished chain. " The customer is having trouble connecting to their Wi-Fi network. I'm helping them troubleshoot the issue and get them connected." conversation_with_summary.predict(input="Is it going well?") > 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: Hi, what's up? AI: Hi there! I'm doing great. I'm currently helping a customer with a technical issue. How about you? Human: What's their issues? AI: The customer is having trouble connecting to their Wi-Fi network. I'm helping them troubleshoot the issue and get them connected. Human: Is it going well? AI: > Finished chain. " Yes, it's going well so far. We've already identified the problem and are now working on a solution." # Notice here that the first interaction does not appear. conversation_with_summary.predict(input="What's the solution?") > 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: What's their issues? AI: The customer is having trouble connecting to their Wi-Fi network. I'm helping them troubleshoot the issue and get them connected. Human: Is it going well? AI: Yes, it's going well so far. We've already identified the problem and are now working on a solution. Human: What's the solution? AI: > Finished chain. " The solution is to reset the router and reconfigure the settings. We're currently in the process of doing that."

https://python.langchain.com/docs/modules/data_connection/retrievers/time_weighted_vectorstore/

## Time-weighted vector store retriever This retriever uses a combination of semantic similarity and a time decay. The algorithm for scoring them is: ``` semantic_similarity + (1.0 - decay_rate) ^ hours_passed ``` Notably, `hours_passed` refers to the hours passed since the object in the retriever **was last accessed**, not since it was created. This means that frequently accessed objects remain “fresh”. ``` from datetime import datetime, timedeltaimport faissfrom langchain.retrievers import TimeWeightedVectorStoreRetrieverfrom langchain_community.docstore import InMemoryDocstorefrom langchain_community.vectorstores import FAISSfrom langchain_core.documents import Documentfrom langchain_openai import OpenAIEmbeddings ``` ## Low decay rate[​](#low-decay-rate "Direct link to Low decay rate") A low `decay rate` (in this, to be extreme, we will set it close to 0) means memories will be “remembered” for longer. A `decay rate` of 0 means memories never be forgotten, making this retriever equivalent to the vector lookup. ``` # Define your embedding modelembeddings_model = OpenAIEmbeddings()# Initialize the vectorstore as emptyembedding_size = 1536index = faiss.IndexFlatL2(embedding_size)vectorstore = FAISS(embeddings_model, index, InMemoryDocstore({}), {})retriever = TimeWeightedVectorStoreRetriever( vectorstore=vectorstore, decay_rate=0.0000000000000000000000001, k=1) ``` ``` yesterday = datetime.now() - timedelta(days=1)retriever.add_documents( [Document(page_content="hello world", metadata={"last_accessed_at": yesterday})])retriever.add_documents([Document(page_content="hello foo")]) ``` ``` ['c3dcf671-3c0a-4273-9334-c4a913076bfa'] ``` ``` # "Hello World" is returned first because it is most salient, and the decay rate is close to 0., meaning it's still recent enoughretriever.get_relevant_documents("hello world") ``` ``` [Document(page_content='hello world', metadata={'last_accessed_at': datetime.datetime(2023, 12, 27, 15, 30, 18, 457125), 'created_at': datetime.datetime(2023, 12, 27, 15, 30, 8, 442662), 'buffer_idx': 0})] ``` ## High decay rate[​](#high-decay-rate "Direct link to High decay rate") With a high `decay rate` (e.g., several 9’s), the `recency score` quickly goes to 0! If you set this all the way to 1, `recency` is 0 for all objects, once again making this equivalent to a vector lookup. ``` # Define your embedding modelembeddings_model = OpenAIEmbeddings()# Initialize the vectorstore as emptyembedding_size = 1536index = faiss.IndexFlatL2(embedding_size)vectorstore = FAISS(embeddings_model, index, InMemoryDocstore({}), {})retriever = TimeWeightedVectorStoreRetriever( vectorstore=vectorstore, decay_rate=0.999, k=1) ``` ``` yesterday = datetime.now() - timedelta(days=1)retriever.add_documents( [Document(page_content="hello world", metadata={"last_accessed_at": yesterday})])retriever.add_documents([Document(page_content="hello foo")]) ``` ``` ['eb1c4c86-01a8-40e3-8393-9a927295a950'] ``` ``` # "Hello Foo" is returned first because "hello world" is mostly forgottenretriever.get_relevant_documents("hello world") ``` ``` [Document(page_content='hello foo', metadata={'last_accessed_at': datetime.datetime(2023, 12, 27, 15, 30, 50, 57185), 'created_at': datetime.datetime(2023, 12, 27, 15, 30, 44, 720490), 'buffer_idx': 1})] ``` ## Virtual time[​](#virtual-time "Direct link to Virtual time") Using some utils in LangChain, you can mock out the time component. ``` import datetimefrom langchain.utils import mock_now ``` ``` # Notice the last access time is that date timewith mock_now(datetime.datetime(2024, 2, 3, 10, 11)): print(retriever.get_relevant_documents("hello world")) ``` ``` [Document(page_content='hello world', metadata={'last_accessed_at': MockDateTime(2024, 2, 3, 10, 11), 'created_at': datetime.datetime(2023, 12, 27, 15, 30, 44, 532941), 'buffer_idx': 0})] ``` * * * #### Help us out by providing feedback on this documentation page:

Time-weighted vector store retriever This retriever uses a combination of semantic similarity and a time decay. The algorithm for scoring them is: semantic_similarity + (1.0 - decay_rate) ^ hours_passed Notably, hours_passed refers to the hours passed since the object in the retriever was last accessed, not since it was created. This means that frequently accessed objects remain “fresh”. from datetime import datetime, timedelta import faiss from langchain.retrievers import TimeWeightedVectorStoreRetriever from langchain_community.docstore import InMemoryDocstore from langchain_community.vectorstores import FAISS from langchain_core.documents import Document from langchain_openai import OpenAIEmbeddings Low decay rate​ A low decay rate (in this, to be extreme, we will set it close to 0) means memories will be “remembered” for longer. A decay rate of 0 means memories never be forgotten, making this retriever equivalent to the vector lookup. # Define your embedding model embeddings_model = OpenAIEmbeddings() # Initialize the vectorstore as empty embedding_size = 1536 index = faiss.IndexFlatL2(embedding_size) vectorstore = FAISS(embeddings_model, index, InMemoryDocstore({}), {}) retriever = TimeWeightedVectorStoreRetriever( vectorstore=vectorstore, decay_rate=0.0000000000000000000000001, k=1 ) yesterday = datetime.now() - timedelta(days=1) retriever.add_documents( [Document(page_content="hello world", metadata={"last_accessed_at": yesterday})] ) retriever.add_documents([Document(page_content="hello foo")]) ['c3dcf671-3c0a-4273-9334-c4a913076bfa'] # "Hello World" is returned first because it is most salient, and the decay rate is close to 0., meaning it's still recent enough retriever.get_relevant_documents("hello world") [Document(page_content='hello world', metadata={'last_accessed_at': datetime.datetime(2023, 12, 27, 15, 30, 18, 457125), 'created_at': datetime.datetime(2023, 12, 27, 15, 30, 8, 442662), 'buffer_idx': 0})] High decay rate​ With a high decay rate (e.g., several 9’s), the recency score quickly goes to 0! If you set this all the way to 1, recency is 0 for all objects, once again making this equivalent to a vector lookup. # Define your embedding model embeddings_model = OpenAIEmbeddings() # Initialize the vectorstore as empty embedding_size = 1536 index = faiss.IndexFlatL2(embedding_size) vectorstore = FAISS(embeddings_model, index, InMemoryDocstore({}), {}) retriever = TimeWeightedVectorStoreRetriever( vectorstore=vectorstore, decay_rate=0.999, k=1 ) yesterday = datetime.now() - timedelta(days=1) retriever.add_documents( [Document(page_content="hello world", metadata={"last_accessed_at": yesterday})] ) retriever.add_documents([Document(page_content="hello foo")]) ['eb1c4c86-01a8-40e3-8393-9a927295a950'] # "Hello Foo" is returned first because "hello world" is mostly forgotten retriever.get_relevant_documents("hello world") [Document(page_content='hello foo', metadata={'last_accessed_at': datetime.datetime(2023, 12, 27, 15, 30, 50, 57185), 'created_at': datetime.datetime(2023, 12, 27, 15, 30, 44, 720490), 'buffer_idx': 1})] Virtual time​ Using some utils in LangChain, you can mock out the time component. import datetime from langchain.utils import mock_now # Notice the last access time is that date time with mock_now(datetime.datetime(2024, 2, 3, 10, 11)): print(retriever.get_relevant_documents("hello world")) [Document(page_content='hello world', metadata={'last_accessed_at': MockDateTime(2024, 2, 3, 10, 11), 'created_at': datetime.datetime(2023, 12, 27, 15, 30, 44, 532941), 'buffer_idx': 0})] Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/modules/data_connection/retrievers/self_query/

## Self-querying Head to [Integrations](https://python.langchain.com/docs/integrations/retrievers/self_query/) for documentation on vector stores with built-in support for self-querying. A self-querying retriever is one that, as the name suggests, has the ability to query itself. Specifically, given any natural language query, the retriever uses a query-constructing LLM chain to write a structured query and then applies that structured query to its underlying VectorStore. This allows the retriever to not only use the user-input query for semantic similarity comparison with the contents of stored documents but to also extract filters from the user query on the metadata of stored documents and to execute those filters.  ## Get started[​](#get-started "Direct link to Get started") For demonstration purposes we’ll use a `Chroma` vector store. We’ve created a small demo set of documents that contain summaries of movies. **Note:** The self-query retriever requires you to have `lark` package installed. ``` %pip install --upgrade --quiet lark langchain-chroma ``` ``` from langchain_chroma import Chromafrom langchain_core.documents import Documentfrom langchain_openai import OpenAIEmbeddingsdocs = [ Document( page_content="A bunch of scientists bring back dinosaurs and mayhem breaks loose", metadata={"year": 1993, "rating": 7.7, "genre": "science fiction"}, ), Document( page_content="Leo DiCaprio gets lost in a dream within a dream within a dream within a ...", metadata={"year": 2010, "director": "Christopher Nolan", "rating": 8.2}, ), Document( page_content="A psychologist / detective gets lost in a series of dreams within dreams within dreams and Inception reused the idea", metadata={"year": 2006, "director": "Satoshi Kon", "rating": 8.6}, ), Document( page_content="A bunch of normal-sized women are supremely wholesome and some men pine after them", metadata={"year": 2019, "director": "Greta Gerwig", "rating": 8.3}, ), Document( page_content="Toys come alive and have a blast doing so", metadata={"year": 1995, "genre": "animated"}, ), Document( page_content="Three men walk into the Zone, three men walk out of the Zone", metadata={ "year": 1979, "director": "Andrei Tarkovsky", "genre": "thriller", "rating": 9.9, }, ),]vectorstore = Chroma.from_documents(docs, OpenAIEmbeddings()) ``` ### Creating our self-querying retriever[​](#creating-our-self-querying-retriever "Direct link to Creating our self-querying retriever") Now we can instantiate our retriever. To do this we’ll need to provide some information upfront about the metadata fields that our documents support and a short description of the document contents. ``` from langchain.chains.query_constructor.base import AttributeInfofrom langchain.retrievers.self_query.base import SelfQueryRetrieverfrom langchain_openai import ChatOpenAImetadata_field_info = [ AttributeInfo( name="genre", description="The genre of the movie. One of ['science fiction', 'comedy', 'drama', 'thriller', 'romance', 'action', 'animated']", type="string", ), AttributeInfo( name="year", description="The year the movie was released", type="integer", ), AttributeInfo( name="director", description="The name of the movie director", type="string", ), AttributeInfo( name="rating", description="A 1-10 rating for the movie", type="float" ),]document_content_description = "Brief summary of a movie"llm = ChatOpenAI(temperature=0)retriever = SelfQueryRetriever.from_llm( llm, vectorstore, document_content_description, metadata_field_info,) ``` ### Testing it out[​](#testing-it-out "Direct link to Testing it out") And now we can actually try using our retriever! ``` # This example only specifies a filterretriever.invoke("I want to watch a movie rated higher than 8.5") ``` ``` [Document(page_content='Three men walk into the Zone, three men walk out of the Zone', metadata={'director': 'Andrei Tarkovsky', 'genre': 'thriller', 'rating': 9.9, 'year': 1979}), Document(page_content='A psychologist / detective gets lost in a series of dreams within dreams within dreams and Inception reused the idea', metadata={'director': 'Satoshi Kon', 'rating': 8.6, 'year': 2006})] ``` ``` # This example specifies a query and a filterretriever.invoke("Has Greta Gerwig directed any movies about women") ``` ``` [Document(page_content='A bunch of normal-sized women are supremely wholesome and some men pine after them', metadata={'director': 'Greta Gerwig', 'rating': 8.3, 'year': 2019})] ``` ``` # This example specifies a composite filterretriever.invoke("What's a highly rated (above 8.5) science fiction film?") ``` ``` [Document(page_content='A psychologist / detective gets lost in a series of dreams within dreams within dreams and Inception reused the idea', metadata={'director': 'Satoshi Kon', 'rating': 8.6, 'year': 2006}), Document(page_content='Three men walk into the Zone, three men walk out of the Zone', metadata={'director': 'Andrei Tarkovsky', 'genre': 'thriller', 'rating': 9.9, 'year': 1979})] ``` ``` # This example specifies a query and composite filterretriever.invoke( "What's a movie after 1990 but before 2005 that's all about toys, and preferably is animated") ``` ``` [Document(page_content='Toys come alive and have a blast doing so', metadata={'genre': 'animated', 'year': 1995})] ``` ### Filter k[​](#filter-k "Direct link to Filter k") We can also use the self query retriever to specify `k`: the number of documents to fetch. We can do this by passing `enable_limit=True` to the constructor. ``` retriever = SelfQueryRetriever.from_llm( llm, vectorstore, document_content_description, metadata_field_info, enable_limit=True,)# This example only specifies a relevant queryretriever.invoke("What are two movies about dinosaurs") ``` ``` [Document(page_content='A bunch of scientists bring back dinosaurs and mayhem breaks loose', metadata={'genre': 'science fiction', 'rating': 7.7, 'year': 1993}), Document(page_content='Toys come alive and have a blast doing so', metadata={'genre': 'animated', 'year': 1995})] ``` ## Constructing from scratch with LCEL[​](#constructing-from-scratch-with-lcel "Direct link to Constructing from scratch with LCEL") To see what’s going on under the hood, and to have more custom control, we can reconstruct our retriever from scratch. First, we need to create a query-construction chain. This chain will take a user query and generated a `StructuredQuery` object which captures the filters specified by the user. We provide some helper functions for creating a prompt and output parser. These have a number of tunable params that we’ll ignore here for simplicity. ``` from langchain.chains.query_constructor.base import ( StructuredQueryOutputParser, get_query_constructor_prompt,)prompt = get_query_constructor_prompt( document_content_description, metadata_field_info,)output_parser = StructuredQueryOutputParser.from_components()query_constructor = prompt | llm | output_parser ``` Let’s look at our prompt: ``` print(prompt.format(query="dummy question")) ``` ``` Your goal is to structure the user's query to match the request schema provided below.<< Structured Request Schema >>When responding use a markdown code snippet with a JSON object formatted in the following schema:```json{ "query": string \ text string to compare to document contents "filter": string \ logical condition statement for filtering documents}```The query string should contain only text that is expected to match the contents of documents. Any conditions in the filter should not be mentioned in the query as well.A logical condition statement is composed of one or more comparison and logical operation statements.A comparison statement takes the form: `comp(attr, val)`:- `comp` (eq | ne | gt | gte | lt | lte | contain | like | in | nin): comparator- `attr` (string): name of attribute to apply the comparison to- `val` (string): is the comparison valueA logical operation statement takes the form `op(statement1, statement2, ...)`:- `op` (and | or | not): logical operator- `statement1`, `statement2`, ... (comparison statements or logical operation statements): one or more statements to apply the operation toMake sure that you only use the comparators and logical operators listed above and no others.Make sure that filters only refer to attributes that exist in the data source.Make sure that filters only use the attributed names with its function names if there are functions applied on them.Make sure that filters only use format `YYYY-MM-DD` when handling date data typed values.Make sure that filters take into account the descriptions of attributes and only make comparisons that are feasible given the type of data being stored.Make sure that filters are only used as needed. If there are no filters that should be applied return "NO_FILTER" for the filter value.<< Example 1. >>Data Source:```json{ "content": "Lyrics of a song", "attributes": { "artist": { "type": "string", "description": "Name of the song artist" }, "length": { "type": "integer", "description": "Length of the song in seconds" }, "genre": { "type": "string", "description": "The song genre, one of "pop", "rock" or "rap"" } }}```User Query:What are songs by Taylor Swift or Katy Perry about teenage romance under 3 minutes long in the dance pop genreStructured Request:```json{ "query": "teenager love", "filter": "and(or(eq(\"artist\", \"Taylor Swift\"), eq(\"artist\", \"Katy Perry\")), lt(\"length\", 180), eq(\"genre\", \"pop\"))"}```<< Example 2. >>Data Source:```json{ "content": "Lyrics of a song", "attributes": { "artist": { "type": "string", "description": "Name of the song artist" }, "length": { "type": "integer", "description": "Length of the song in seconds" }, "genre": { "type": "string", "description": "The song genre, one of "pop", "rock" or "rap"" } }}```User Query:What are songs that were not published on SpotifyStructured Request:```json{ "query": "", "filter": "NO_FILTER"}```<< Example 3. >>Data Source:```json{ "content": "Brief summary of a movie", "attributes": { "genre": { "description": "The genre of the movie. One of ['science fiction', 'comedy', 'drama', 'thriller', 'romance', 'action', 'animated']", "type": "string" }, "year": { "description": "The year the movie was released", "type": "integer" }, "director": { "description": "The name of the movie director", "type": "string" }, "rating": { "description": "A 1-10 rating for the movie", "type": "float" }}}```User Query:dummy questionStructured Request: ``` And what our full chain produces: ``` query_constructor.invoke( { "query": "What are some sci-fi movies from the 90's directed by Luc Besson about taxi drivers" }) ``` ``` StructuredQuery(query='taxi driver', filter=Operation(operator=<Operator.AND: 'and'>, arguments=[Comparison(comparator=<Comparator.EQ: 'eq'>, attribute='genre', value='science fiction'), Operation(operator=<Operator.AND: 'and'>, arguments=[Comparison(comparator=<Comparator.GTE: 'gte'>, attribute='year', value=1990), Comparison(comparator=<Comparator.LT: 'lt'>, attribute='year', value=2000)]), Comparison(comparator=<Comparator.EQ: 'eq'>, attribute='director', value='Luc Besson')]), limit=None) ``` The query constructor is the key element of the self-query retriever. To make a great retrieval system you’ll need to make sure your query constructor works well. Often this requires adjusting the prompt, the examples in the prompt, the attribute descriptions, etc. For an example that walks through refining a query constructor on some hotel inventory data, [check out this cookbook](https://github.com/langchain-ai/langchain/blob/master/cookbook/self_query_hotel_search.ipynb). The next key element is the structured query translator. This is the object responsible for translating the generic `StructuredQuery` object into a metadata filter in the syntax of the vector store you’re using. LangChain comes with a number of built-in translators. To see them all head to the [Integrations section](https://python.langchain.com/docs/integrations/retrievers/self_query/). ``` from langchain.retrievers.self_query.chroma import ChromaTranslatorretriever = SelfQueryRetriever( query_constructor=query_constructor, vectorstore=vectorstore, structured_query_translator=ChromaTranslator(),) ``` ``` retriever.invoke( "What's a movie after 1990 but before 2005 that's all about toys, and preferably is animated") ``` ``` [Document(page_content='Toys come alive and have a blast doing so', metadata={'genre': 'animated', 'year': 1995})] ```

Self-querying Head to Integrations for documentation on vector stores with built-in support for self-querying. A self-querying retriever is one that, as the name suggests, has the ability to query itself. Specifically, given any natural language query, the retriever uses a query-constructing LLM chain to write a structured query and then applies that structured query to its underlying VectorStore. This allows the retriever to not only use the user-input query for semantic similarity comparison with the contents of stored documents but to also extract filters from the user query on the metadata of stored documents and to execute those filters. Get started​ For demonstration purposes we’ll use a Chroma vector store. We’ve created a small demo set of documents that contain summaries of movies. Note: The self-query retriever requires you to have lark package installed. %pip install --upgrade --quiet lark langchain-chroma from langchain_chroma import Chroma from langchain_core.documents import Document from langchain_openai import OpenAIEmbeddings docs = [ Document( page_content="A bunch of scientists bring back dinosaurs and mayhem breaks loose", metadata={"year": 1993, "rating": 7.7, "genre": "science fiction"}, ), Document( page_content="Leo DiCaprio gets lost in a dream within a dream within a dream within a ...", metadata={"year": 2010, "director": "Christopher Nolan", "rating": 8.2}, ), Document( page_content="A psychologist / detective gets lost in a series of dreams within dreams within dreams and Inception reused the idea", metadata={"year": 2006, "director": "Satoshi Kon", "rating": 8.6}, ), Document( page_content="A bunch of normal-sized women are supremely wholesome and some men pine after them", metadata={"year": 2019, "director": "Greta Gerwig", "rating": 8.3}, ), Document( page_content="Toys come alive and have a blast doing so", metadata={"year": 1995, "genre": "animated"}, ), Document( page_content="Three men walk into the Zone, three men walk out of the Zone", metadata={ "year": 1979, "director": "Andrei Tarkovsky", "genre": "thriller", "rating": 9.9, }, ), ] vectorstore = Chroma.from_documents(docs, OpenAIEmbeddings()) Creating our self-querying retriever​ Now we can instantiate our retriever. To do this we’ll need to provide some information upfront about the metadata fields that our documents support and a short description of the document contents. from langchain.chains.query_constructor.base import AttributeInfo from langchain.retrievers.self_query.base import SelfQueryRetriever from langchain_openai import ChatOpenAI metadata_field_info = [ AttributeInfo( name="genre", description="The genre of the movie. One of ['science fiction', 'comedy', 'drama', 'thriller', 'romance', 'action', 'animated']", type="string", ), AttributeInfo( name="year", description="The year the movie was released", type="integer", ), AttributeInfo( name="director", description="The name of the movie director", type="string", ), AttributeInfo( name="rating", description="A 1-10 rating for the movie", type="float" ), ] document_content_description = "Brief summary of a movie" llm = ChatOpenAI(temperature=0) retriever = SelfQueryRetriever.from_llm( llm, vectorstore, document_content_description, metadata_field_info, ) Testing it out​ And now we can actually try using our retriever! # This example only specifies a filter retriever.invoke("I want to watch a movie rated higher than 8.5") [Document(page_content='Three men walk into the Zone, three men walk out of the Zone', metadata={'director': 'Andrei Tarkovsky', 'genre': 'thriller', 'rating': 9.9, 'year': 1979}), Document(page_content='A psychologist / detective gets lost in a series of dreams within dreams within dreams and Inception reused the idea', metadata={'director': 'Satoshi Kon', 'rating': 8.6, 'year': 2006})] # This example specifies a query and a filter retriever.invoke("Has Greta Gerwig directed any movies about women") [Document(page_content='A bunch of normal-sized women are supremely wholesome and some men pine after them', metadata={'director': 'Greta Gerwig', 'rating': 8.3, 'year': 2019})] # This example specifies a composite filter retriever.invoke("What's a highly rated (above 8.5) science fiction film?") [Document(page_content='A psychologist / detective gets lost in a series of dreams within dreams within dreams and Inception reused the idea', metadata={'director': 'Satoshi Kon', 'rating': 8.6, 'year': 2006}), Document(page_content='Three men walk into the Zone, three men walk out of the Zone', metadata={'director': 'Andrei Tarkovsky', 'genre': 'thriller', 'rating': 9.9, 'year': 1979})] # This example specifies a query and composite filter retriever.invoke( "What's a movie after 1990 but before 2005 that's all about toys, and preferably is animated" ) [Document(page_content='Toys come alive and have a blast doing so', metadata={'genre': 'animated', 'year': 1995})] Filter k​ We can also use the self query retriever to specify k: the number of documents to fetch. We can do this by passing enable_limit=True to the constructor. retriever = SelfQueryRetriever.from_llm( llm, vectorstore, document_content_description, metadata_field_info, enable_limit=True, ) # This example only specifies a relevant query retriever.invoke("What are two movies about dinosaurs") [Document(page_content='A bunch of scientists bring back dinosaurs and mayhem breaks loose', metadata={'genre': 'science fiction', 'rating': 7.7, 'year': 1993}), Document(page_content='Toys come alive and have a blast doing so', metadata={'genre': 'animated', 'year': 1995})] Constructing from scratch with LCEL​ To see what’s going on under the hood, and to have more custom control, we can reconstruct our retriever from scratch. First, we need to create a query-construction chain. This chain will take a user query and generated a StructuredQuery object which captures the filters specified by the user. We provide some helper functions for creating a prompt and output parser. These have a number of tunable params that we’ll ignore here for simplicity. from langchain.chains.query_constructor.base import ( StructuredQueryOutputParser, get_query_constructor_prompt, ) prompt = get_query_constructor_prompt( document_content_description, metadata_field_info, ) output_parser = StructuredQueryOutputParser.from_components() query_constructor = prompt | llm | output_parser Let’s look at our prompt: print(prompt.format(query="dummy question")) Your goal is to structure the user's query to match the request schema provided below. << Structured Request Schema >> When responding use a markdown code snippet with a JSON object formatted in the following schema: ```json { "query": string \ text string to compare to document contents "filter": string \ logical condition statement for filtering documents } ``` The query string should contain only text that is expected to match the contents of documents. Any conditions in the filter should not be mentioned in the query as well. A logical condition statement is composed of one or more comparison and logical operation statements. A comparison statement takes the form: `comp(attr, val)`: - `comp` (eq | ne | gt | gte | lt | lte | contain | like | in | nin): comparator - `attr` (string): name of attribute to apply the comparison to - `val` (string): is the comparison value A logical operation statement takes the form `op(statement1, statement2, ...)`: - `op` (and | or | not): logical operator - `statement1`, `statement2`, ... (comparison statements or logical operation statements): one or more statements to apply the operation to Make sure that you only use the comparators and logical operators listed above and no others. Make sure that filters only refer to attributes that exist in the data source. Make sure that filters only use the attributed names with its function names if there are functions applied on them. Make sure that filters only use format `YYYY-MM-DD` when handling date data typed values. Make sure that filters take into account the descriptions of attributes and only make comparisons that are feasible given the type of data being stored. Make sure that filters are only used as needed. If there are no filters that should be applied return "NO_FILTER" for the filter value. << Example 1. >> Data Source: ```json { "content": "Lyrics of a song", "attributes": { "artist": { "type": "string", "description": "Name of the song artist" }, "length": { "type": "integer", "description": "Length of the song in seconds" }, "genre": { "type": "string", "description": "The song genre, one of "pop", "rock" or "rap"" } } } ``` User Query: What are songs by Taylor Swift or Katy Perry about teenage romance under 3 minutes long in the dance pop genre Structured Request: ```json { "query": "teenager love", "filter": "and(or(eq(\"artist\", \"Taylor Swift\"), eq(\"artist\", \"Katy Perry\")), lt(\"length\", 180), eq(\"genre\", \"pop\"))" } ``` << Example 2. >> Data Source: ```json { "content": "Lyrics of a song", "attributes": { "artist": { "type": "string", "description": "Name of the song artist" }, "length": { "type": "integer", "description": "Length of the song in seconds" }, "genre": { "type": "string", "description": "The song genre, one of "pop", "rock" or "rap"" } } } ``` User Query: What are songs that were not published on Spotify Structured Request: ```json { "query": "", "filter": "NO_FILTER" } ``` << Example 3. >> Data Source: ```json { "content": "Brief summary of a movie", "attributes": { "genre": { "description": "The genre of the movie. One of ['science fiction', 'comedy', 'drama', 'thriller', 'romance', 'action', 'animated']", "type": "string" }, "year": { "description": "The year the movie was released", "type": "integer" }, "director": { "description": "The name of the movie director", "type": "string" }, "rating": { "description": "A 1-10 rating for the movie", "type": "float" } } } ``` User Query: dummy question Structured Request: And what our full chain produces: query_constructor.invoke( { "query": "What are some sci-fi movies from the 90's directed by Luc Besson about taxi drivers" } ) StructuredQuery(query='taxi driver', filter=Operation(operator=<Operator.AND: 'and'>, arguments=[Comparison(comparator=<Comparator.EQ: 'eq'>, attribute='genre', value='science fiction'), Operation(operator=<Operator.AND: 'and'>, arguments=[Comparison(comparator=<Comparator.GTE: 'gte'>, attribute='year', value=1990), Comparison(comparator=<Comparator.LT: 'lt'>, attribute='year', value=2000)]), Comparison(comparator=<Comparator.EQ: 'eq'>, attribute='director', value='Luc Besson')]), limit=None) The query constructor is the key element of the self-query retriever. To make a great retrieval system you’ll need to make sure your query constructor works well. Often this requires adjusting the prompt, the examples in the prompt, the attribute descriptions, etc. For an example that walks through refining a query constructor on some hotel inventory data, check out this cookbook. The next key element is the structured query translator. This is the object responsible for translating the generic StructuredQuery object into a metadata filter in the syntax of the vector store you’re using. LangChain comes with a number of built-in translators. To see them all head to the Integrations section. from langchain.retrievers.self_query.chroma import ChromaTranslator retriever = SelfQueryRetriever( query_constructor=query_constructor, vectorstore=vectorstore, structured_query_translator=ChromaTranslator(), ) retriever.invoke( "What's a movie after 1990 but before 2005 that's all about toys, and preferably is animated" ) [Document(page_content='Toys come alive and have a blast doing so', metadata={'genre': 'animated', 'year': 1995})]

https://python.langchain.com/docs/modules/memory/types/buffer/

## Conversation Buffer This notebook shows how to use `ConversationBufferMemory`. This memory allows for storing messages and then extracts the messages in a variable. We can first extract it as a string. ``` from langchain.memory import ConversationBufferMemory ``` ``` memory = ConversationBufferMemory()memory.save_context({"input": "hi"}, {"output": "whats up"}) ``` ``` memory.load_memory_variables({}) ``` ``` {'history': 'Human: hi\nAI: whats up'} ``` We can also get the history as a list of messages (this is useful if you are using this with a chat model). ``` memory = ConversationBufferMemory(return_messages=True)memory.save_context({"input": "hi"}, {"output": "whats up"}) ``` ``` memory.load_memory_variables({}) ``` ``` {'history': [HumanMessage(content='hi', additional_kwargs={}), AIMessage(content='whats up', additional_kwargs={})]} ``` ## Using in a chain[​](#using-in-a-chain "Direct link to Using in a chain") Finally, let's take a look at using this in a chain (setting `verbose=True` so we can see the prompt). ``` from langchain_openai import OpenAIfrom langchain.chains import ConversationChainllm = OpenAI(temperature=0)conversation = ConversationChain( llm=llm, verbose=True, memory=ConversationBufferMemory()) ``` ``` conversation.predict(input="Hi there!") ``` ``` > 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: Hi there! AI: > Finished chain. " Hi there! It's nice to meet you. How can I help you today?" ``` ``` conversation.predict(input="I'm doing well! Just having a conversation with an AI.") ``` ``` > 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: Hi there! AI: Hi there! It's nice to meet you. How can I help you today? Human: I'm doing well! Just having a conversation with an AI. AI: > Finished chain. " That's great! It's always nice to have a conversation with someone new. What would you like to talk about?" ``` ``` conversation.predict(input="Tell me about yourself.") ``` ``` > 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: Hi there! AI: Hi there! It's nice to meet you. How can I help you today? Human: I'm doing well! Just having a conversation with an AI. AI: That's great! It's always nice to have a conversation with someone new. What would you like to talk about? Human: Tell me about yourself. AI: > Finished chain. " Sure! I'm an AI created to help people with their everyday tasks. I'm programmed to understand natural language and provide helpful information. I'm also constantly learning and updating my knowledge base so I can provide more accurate and helpful answers." ```

Conversation Buffer This notebook shows how to use ConversationBufferMemory. This memory allows for storing messages and then extracts the messages in a variable. We can first extract it as a string. from langchain.memory import ConversationBufferMemory memory = ConversationBufferMemory() memory.save_context({"input": "hi"}, {"output": "whats up"}) memory.load_memory_variables({}) {'history': 'Human: hi\nAI: whats up'} We can also get the history as a list of messages (this is useful if you are using this with a chat model). memory = ConversationBufferMemory(return_messages=True) memory.save_context({"input": "hi"}, {"output": "whats up"}) memory.load_memory_variables({}) {'history': [HumanMessage(content='hi', additional_kwargs={}), AIMessage(content='whats up', additional_kwargs={})]} Using in a chain​ Finally, let's take a look at using this in a chain (setting verbose=True so we can see the prompt). from langchain_openai import OpenAI from langchain.chains import ConversationChain llm = OpenAI(temperature=0) conversation = ConversationChain( llm=llm, verbose=True, memory=ConversationBufferMemory() ) conversation.predict(input="Hi there!") > 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: Hi there! AI: > Finished chain. " Hi there! It's nice to meet you. How can I help you today?" conversation.predict(input="I'm doing well! Just having a conversation with an AI.") > 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: Hi there! AI: Hi there! It's nice to meet you. How can I help you today? Human: I'm doing well! Just having a conversation with an AI. AI: > Finished chain. " That's great! It's always nice to have a conversation with someone new. What would you like to talk about?" conversation.predict(input="Tell me about yourself.") > 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: Hi there! AI: Hi there! It's nice to meet you. How can I help you today? Human: I'm doing well! Just having a conversation with an AI. AI: That's great! It's always nice to have a conversation with someone new. What would you like to talk about? Human: Tell me about yourself. AI: > Finished chain. " Sure! I'm an AI created to help people with their everyday tasks. I'm programmed to understand natural language and provide helpful information. I'm also constantly learning and updating my knowledge base so I can provide more accurate and helpful answers."

https://python.langchain.com/docs/modules/memory/types/entity_summary_memory/

## Entity Entity memory remembers given facts about specific entities in a conversation. It extracts information on entities (using an LLM) and builds up its knowledge about that entity over time (also using an LLM). Let's first walk through using this functionality. ``` from langchain_openai import OpenAIfrom langchain.memory import ConversationEntityMemoryllm = OpenAI(temperature=0) ``` ``` memory = ConversationEntityMemory(llm=llm)_input = {"input": "Deven & Sam are working on a hackathon project"}memory.load_memory_variables(_input)memory.save_context( _input, {"output": " That sounds like a great project! What kind of project are they working on?"}) ``` ``` memory.load_memory_variables({"input": 'who is Sam'}) ``` ``` {'history': 'Human: Deven & Sam are working on a hackathon project\nAI: That sounds like a great project! What kind of project are they working on?', 'entities': {'Sam': 'Sam is working on a hackathon project with Deven.'}} ``` ``` memory = ConversationEntityMemory(llm=llm, return_messages=True)_input = {"input": "Deven & Sam are working on a hackathon project"}memory.load_memory_variables(_input)memory.save_context( _input, {"output": " That sounds like a great project! What kind of project are they working on?"}) ``` ``` memory.load_memory_variables({"input": 'who is Sam'}) ``` ``` {'history': [HumanMessage(content='Deven & Sam are working on a hackathon project', additional_kwargs={}), AIMessage(content=' That sounds like a great project! What kind of project are they working on?', additional_kwargs={})], 'entities': {'Sam': 'Sam is working on a hackathon project with Deven.'}} ``` ## Using in a chain[​](#using-in-a-chain "Direct link to Using in a chain") Let's now use it in a chain! ``` from langchain.chains import ConversationChainfrom langchain.memory import ConversationEntityMemoryfrom langchain.memory.prompt import ENTITY_MEMORY_CONVERSATION_TEMPLATEfrom pydantic import BaseModelfrom typing import List, Dict, Any ``` ``` conversation = ConversationChain( llm=llm, verbose=True, prompt=ENTITY_MEMORY_CONVERSATION_TEMPLATE, memory=ConversationEntityMemory(llm=llm)) ``` ``` conversation.predict(input="Deven & Sam are working on a hackathon project") ``` ``` > Entering new ConversationChain chain... Prompt after formatting: You are an assistant to a human, powered by a large language model trained by OpenAI. You are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand. You are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics. Overall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist. Context: {'Deven': 'Deven is working on a hackathon project with Sam.', 'Sam': 'Sam is working on a hackathon project with Deven.'} Current conversation: Last line: Human: Deven & Sam are working on a hackathon project You: > Finished chain. ' That sounds like a great project! What kind of project are they working on?' ``` ``` conversation.memory.entity_store.store ``` ``` {'Deven': 'Deven is working on a hackathon project with Sam, which they are entering into a hackathon.', 'Sam': 'Sam is working on a hackathon project with Deven.'} ``` ``` conversation.predict(input="They are trying to add more complex memory structures to Langchain") ``` ``` > Entering new ConversationChain chain... Prompt after formatting: You are an assistant to a human, powered by a large language model trained by OpenAI. You are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand. You are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics. Overall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist. Context: {'Deven': 'Deven is working on a hackathon project with Sam, which they are entering into a hackathon.', 'Sam': 'Sam is working on a hackathon project with Deven.', 'Langchain': ''} Current conversation: Human: Deven & Sam are working on a hackathon project AI: That sounds like a great project! What kind of project are they working on? Last line: Human: They are trying to add more complex memory structures to Langchain You: > Finished chain. ' That sounds like an interesting project! What kind of memory structures are they trying to add?' ``` ``` conversation.predict(input="They are adding in a key-value store for entities mentioned so far in the conversation.") ``` ``` > Entering new ConversationChain chain... Prompt after formatting: You are an assistant to a human, powered by a large language model trained by OpenAI. You are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand. You are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics. Overall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist. Context: {'Deven': 'Deven is working on a hackathon project with Sam, which they are entering into a hackathon. They are trying to add more complex memory structures to Langchain.', 'Sam': 'Sam is working on a hackathon project with Deven, trying to add more complex memory structures to Langchain.', 'Langchain': 'Langchain is a project that is trying to add more complex memory structures.', 'Key-Value Store': ''} Current conversation: Human: Deven & Sam are working on a hackathon project AI: That sounds like a great project! What kind of project are they working on? Human: They are trying to add more complex memory structures to Langchain AI: That sounds like an interesting project! What kind of memory structures are they trying to add? Last line: Human: They are adding in a key-value store for entities mentioned so far in the conversation. You: > Finished chain. ' That sounds like a great idea! How will the key-value store help with the project?' ``` ``` conversation.predict(input="What do you know about Deven & Sam?") ``` ``` > Entering new ConversationChain chain... Prompt after formatting: You are an assistant to a human, powered by a large language model trained by OpenAI. You are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand. You are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics. Overall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist. Context: {'Deven': 'Deven is working on a hackathon project with Sam, which they are entering into a hackathon. They are trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation.', 'Sam': 'Sam is working on a hackathon project with Deven, trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation.'} Current conversation: Human: Deven & Sam are working on a hackathon project AI: That sounds like a great project! What kind of project are they working on? Human: They are trying to add more complex memory structures to Langchain AI: That sounds like an interesting project! What kind of memory structures are they trying to add? Human: They are adding in a key-value store for entities mentioned so far in the conversation. AI: That sounds like a great idea! How will the key-value store help with the project? Last line: Human: What do you know about Deven & Sam? You: > Finished chain. ' Deven and Sam are working on a hackathon project together, trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation. They seem to be working hard on this project and have a great idea for how the key-value store can help.' ``` ## Inspecting the memory store[​](#inspecting-the-memory-store "Direct link to Inspecting the memory store") We can also inspect the memory store directly. In the following examples, we look at it directly, and then go through some examples of adding information and watch how it changes. ``` from pprint import pprintpprint(conversation.memory.entity_store.store) ``` ``` {'Daimon': 'Daimon is a company founded by Sam, a successful entrepreneur.', 'Deven': 'Deven is working on a hackathon project with Sam, which they are ' 'entering into a hackathon. They are trying to add more complex ' 'memory structures to Langchain, including a key-value store for ' 'entities mentioned so far in the conversation, and seem to be ' 'working hard on this project with a great idea for how the ' 'key-value store can help.', 'Key-Value Store': 'A key-value store is being added to the project to store ' 'entities mentioned in the conversation.', 'Langchain': 'Langchain is a project that is trying to add more complex ' 'memory structures, including a key-value store for entities ' 'mentioned so far in the conversation.', 'Sam': 'Sam is working on a hackathon project with Deven, trying to add more ' 'complex memory structures to Langchain, including a key-value store ' 'for entities mentioned so far in the conversation. They seem to have ' 'a great idea for how the key-value store can help, and Sam is also ' 'the founder of a company called Daimon.'} ``` ``` conversation.predict(input="Sam is the founder of a company called Daimon.") ``` ``` > Entering new ConversationChain chain... Prompt after formatting: You are an assistant to a human, powered by a large language model trained by OpenAI. You are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand. You are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics. Overall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist. Context: {'Daimon': 'Daimon is a company founded by Sam, a successful entrepreneur.', 'Sam': 'Sam is working on a hackathon project with Deven, trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation. They seem to have a great idea for how the key-value store can help, and Sam is also the founder of a company called Daimon.'} Current conversation: Human: They are adding in a key-value store for entities mentioned so far in the conversation. AI: That sounds like a great idea! How will the key-value store help with the project? Human: What do you know about Deven & Sam? AI: Deven and Sam are working on a hackathon project together, trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation. They seem to be working hard on this project and have a great idea for how the key-value store can help. Human: Sam is the founder of a company called Daimon. AI: That's impressive! It sounds like Sam is a very successful entrepreneur. What kind of company is Daimon? Last line: Human: Sam is the founder of a company called Daimon. You: > Finished chain. " That's impressive! It sounds like Sam is a very successful entrepreneur. What kind of company is Daimon?" ``` ``` from pprint import pprintpprint(conversation.memory.entity_store.store) ``` ``` {'Daimon': 'Daimon is a company founded by Sam, a successful entrepreneur, who ' 'is working on a hackathon project with Deven to add more complex ' 'memory structures to Langchain.', 'Deven': 'Deven is working on a hackathon project with Sam, which they are ' 'entering into a hackathon. They are trying to add more complex ' 'memory structures to Langchain, including a key-value store for ' 'entities mentioned so far in the conversation, and seem to be ' 'working hard on this project with a great idea for how the ' 'key-value store can help.', 'Key-Value Store': 'A key-value store is being added to the project to store ' 'entities mentioned in the conversation.', 'Langchain': 'Langchain is a project that is trying to add more complex ' 'memory structures, including a key-value store for entities ' 'mentioned so far in the conversation.', 'Sam': 'Sam is working on a hackathon project with Deven, trying to add more ' 'complex memory structures to Langchain, including a key-value store ' 'for entities mentioned so far in the conversation. They seem to have ' 'a great idea for how the key-value store can help, and Sam is also ' 'the founder of a successful company called Daimon.'} ``` ``` conversation.predict(input="What do you know about Sam?") ``` ``` > Entering new ConversationChain chain... Prompt after formatting: You are an assistant to a human, powered by a large language model trained by OpenAI. You are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand. You are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics. Overall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist. Context: {'Deven': 'Deven is working on a hackathon project with Sam, which they are entering into a hackathon. They are trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation, and seem to be working hard on this project with a great idea for how the key-value store can help.', 'Sam': 'Sam is working on a hackathon project with Deven, trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation. They seem to have a great idea for how the key-value store can help, and Sam is also the founder of a successful company called Daimon.', 'Langchain': 'Langchain is a project that is trying to add more complex memory structures, including a key-value store for entities mentioned so far in the conversation.', 'Daimon': 'Daimon is a company founded by Sam, a successful entrepreneur, who is working on a hackathon project with Deven to add more complex memory structures to Langchain.'} Current conversation: Human: What do you know about Deven & Sam? AI: Deven and Sam are working on a hackathon project together, trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation. They seem to be working hard on this project and have a great idea for how the key-value store can help. Human: Sam is the founder of a company called Daimon. AI: That's impressive! It sounds like Sam is a very successful entrepreneur. What kind of company is Daimon? Human: Sam is the founder of a company called Daimon. AI: That's impressive! It sounds like Sam is a very successful entrepreneur. What kind of company is Daimon? Last line: Human: What do you know about Sam? You: > Finished chain. ' Sam is the founder of a successful company called Daimon. He is also working on a hackathon project with Deven to add more complex memory structures to Langchain. They seem to have a great idea for how the key-value store can help.' ```

Entity Entity memory remembers given facts about specific entities in a conversation. It extracts information on entities (using an LLM) and builds up its knowledge about that entity over time (also using an LLM). Let's first walk through using this functionality. from langchain_openai import OpenAI from langchain.memory import ConversationEntityMemory llm = OpenAI(temperature=0) memory = ConversationEntityMemory(llm=llm) _input = {"input": "Deven & Sam are working on a hackathon project"} memory.load_memory_variables(_input) memory.save_context( _input, {"output": " That sounds like a great project! What kind of project are they working on?"} ) memory.load_memory_variables({"input": 'who is Sam'}) {'history': 'Human: Deven & Sam are working on a hackathon project\nAI: That sounds like a great project! What kind of project are they working on?', 'entities': {'Sam': 'Sam is working on a hackathon project with Deven.'}} memory = ConversationEntityMemory(llm=llm, return_messages=True) _input = {"input": "Deven & Sam are working on a hackathon project"} memory.load_memory_variables(_input) memory.save_context( _input, {"output": " That sounds like a great project! What kind of project are they working on?"} ) memory.load_memory_variables({"input": 'who is Sam'}) {'history': [HumanMessage(content='Deven & Sam are working on a hackathon project', additional_kwargs={}), AIMessage(content=' That sounds like a great project! What kind of project are they working on?', additional_kwargs={})], 'entities': {'Sam': 'Sam is working on a hackathon project with Deven.'}} Using in a chain​ Let's now use it in a chain! from langchain.chains import ConversationChain from langchain.memory import ConversationEntityMemory from langchain.memory.prompt import ENTITY_MEMORY_CONVERSATION_TEMPLATE from pydantic import BaseModel from typing import List, Dict, Any conversation = ConversationChain( llm=llm, verbose=True, prompt=ENTITY_MEMORY_CONVERSATION_TEMPLATE, memory=ConversationEntityMemory(llm=llm) ) conversation.predict(input="Deven & Sam are working on a hackathon project") > Entering new ConversationChain chain... Prompt after formatting: You are an assistant to a human, powered by a large language model trained by OpenAI. You are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand. You are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics. Overall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist. Context: {'Deven': 'Deven is working on a hackathon project with Sam.', 'Sam': 'Sam is working on a hackathon project with Deven.'} Current conversation: Last line: Human: Deven & Sam are working on a hackathon project You: > Finished chain. ' That sounds like a great project! What kind of project are they working on?' conversation.memory.entity_store.store {'Deven': 'Deven is working on a hackathon project with Sam, which they are entering into a hackathon.', 'Sam': 'Sam is working on a hackathon project with Deven.'} conversation.predict(input="They are trying to add more complex memory structures to Langchain") > Entering new ConversationChain chain... Prompt after formatting: You are an assistant to a human, powered by a large language model trained by OpenAI. You are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand. You are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics. Overall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist. Context: {'Deven': 'Deven is working on a hackathon project with Sam, which they are entering into a hackathon.', 'Sam': 'Sam is working on a hackathon project with Deven.', 'Langchain': ''} Current conversation: Human: Deven & Sam are working on a hackathon project AI: That sounds like a great project! What kind of project are they working on? Last line: Human: They are trying to add more complex memory structures to Langchain You: > Finished chain. ' That sounds like an interesting project! What kind of memory structures are they trying to add?' conversation.predict(input="They are adding in a key-value store for entities mentioned so far in the conversation.") > Entering new ConversationChain chain... Prompt after formatting: You are an assistant to a human, powered by a large language model trained by OpenAI. You are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand. You are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics. Overall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist. Context: {'Deven': 'Deven is working on a hackathon project with Sam, which they are entering into a hackathon. They are trying to add more complex memory structures to Langchain.', 'Sam': 'Sam is working on a hackathon project with Deven, trying to add more complex memory structures to Langchain.', 'Langchain': 'Langchain is a project that is trying to add more complex memory structures.', 'Key-Value Store': ''} Current conversation: Human: Deven & Sam are working on a hackathon project AI: That sounds like a great project! What kind of project are they working on? Human: They are trying to add more complex memory structures to Langchain AI: That sounds like an interesting project! What kind of memory structures are they trying to add? Last line: Human: They are adding in a key-value store for entities mentioned so far in the conversation. You: > Finished chain. ' That sounds like a great idea! How will the key-value store help with the project?' conversation.predict(input="What do you know about Deven & Sam?") > Entering new ConversationChain chain... Prompt after formatting: You are an assistant to a human, powered by a large language model trained by OpenAI. You are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand. You are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics. Overall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist. Context: {'Deven': 'Deven is working on a hackathon project with Sam, which they are entering into a hackathon. They are trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation.', 'Sam': 'Sam is working on a hackathon project with Deven, trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation.'} Current conversation: Human: Deven & Sam are working on a hackathon project AI: That sounds like a great project! What kind of project are they working on? Human: They are trying to add more complex memory structures to Langchain AI: That sounds like an interesting project! What kind of memory structures are they trying to add? Human: They are adding in a key-value store for entities mentioned so far in the conversation. AI: That sounds like a great idea! How will the key-value store help with the project? Last line: Human: What do you know about Deven & Sam? You: > Finished chain. ' Deven and Sam are working on a hackathon project together, trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation. They seem to be working hard on this project and have a great idea for how the key-value store can help.' Inspecting the memory store​ We can also inspect the memory store directly. In the following examples, we look at it directly, and then go through some examples of adding information and watch how it changes. from pprint import pprint pprint(conversation.memory.entity_store.store) {'Daimon': 'Daimon is a company founded by Sam, a successful entrepreneur.', 'Deven': 'Deven is working on a hackathon project with Sam, which they are ' 'entering into a hackathon. They are trying to add more complex ' 'memory structures to Langchain, including a key-value store for ' 'entities mentioned so far in the conversation, and seem to be ' 'working hard on this project with a great idea for how the ' 'key-value store can help.', 'Key-Value Store': 'A key-value store is being added to the project to store ' 'entities mentioned in the conversation.', 'Langchain': 'Langchain is a project that is trying to add more complex ' 'memory structures, including a key-value store for entities ' 'mentioned so far in the conversation.', 'Sam': 'Sam is working on a hackathon project with Deven, trying to add more ' 'complex memory structures to Langchain, including a key-value store ' 'for entities mentioned so far in the conversation. They seem to have ' 'a great idea for how the key-value store can help, and Sam is also ' 'the founder of a company called Daimon.'} conversation.predict(input="Sam is the founder of a company called Daimon.") > Entering new ConversationChain chain... Prompt after formatting: You are an assistant to a human, powered by a large language model trained by OpenAI. You are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand. You are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics. Overall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist. Context: {'Daimon': 'Daimon is a company founded by Sam, a successful entrepreneur.', 'Sam': 'Sam is working on a hackathon project with Deven, trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation. They seem to have a great idea for how the key-value store can help, and Sam is also the founder of a company called Daimon.'} Current conversation: Human: They are adding in a key-value store for entities mentioned so far in the conversation. AI: That sounds like a great idea! How will the key-value store help with the project? Human: What do you know about Deven & Sam? AI: Deven and Sam are working on a hackathon project together, trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation. They seem to be working hard on this project and have a great idea for how the key-value store can help. Human: Sam is the founder of a company called Daimon. AI: That's impressive! It sounds like Sam is a very successful entrepreneur. What kind of company is Daimon? Last line: Human: Sam is the founder of a company called Daimon. You: > Finished chain. " That's impressive! It sounds like Sam is a very successful entrepreneur. What kind of company is Daimon?" from pprint import pprint pprint(conversation.memory.entity_store.store) {'Daimon': 'Daimon is a company founded by Sam, a successful entrepreneur, who ' 'is working on a hackathon project with Deven to add more complex ' 'memory structures to Langchain.', 'Deven': 'Deven is working on a hackathon project with Sam, which they are ' 'entering into a hackathon. They are trying to add more complex ' 'memory structures to Langchain, including a key-value store for ' 'entities mentioned so far in the conversation, and seem to be ' 'working hard on this project with a great idea for how the ' 'key-value store can help.', 'Key-Value Store': 'A key-value store is being added to the project to store ' 'entities mentioned in the conversation.', 'Langchain': 'Langchain is a project that is trying to add more complex ' 'memory structures, including a key-value store for entities ' 'mentioned so far in the conversation.', 'Sam': 'Sam is working on a hackathon project with Deven, trying to add more ' 'complex memory structures to Langchain, including a key-value store ' 'for entities mentioned so far in the conversation. They seem to have ' 'a great idea for how the key-value store can help, and Sam is also ' 'the founder of a successful company called Daimon.'} conversation.predict(input="What do you know about Sam?") > Entering new ConversationChain chain... Prompt after formatting: You are an assistant to a human, powered by a large language model trained by OpenAI. You are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand. You are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics. Overall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist. Context: {'Deven': 'Deven is working on a hackathon project with Sam, which they are entering into a hackathon. They are trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation, and seem to be working hard on this project with a great idea for how the key-value store can help.', 'Sam': 'Sam is working on a hackathon project with Deven, trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation. They seem to have a great idea for how the key-value store can help, and Sam is also the founder of a successful company called Daimon.', 'Langchain': 'Langchain is a project that is trying to add more complex memory structures, including a key-value store for entities mentioned so far in the conversation.', 'Daimon': 'Daimon is a company founded by Sam, a successful entrepreneur, who is working on a hackathon project with Deven to add more complex memory structures to Langchain.'} Current conversation: Human: What do you know about Deven & Sam? AI: Deven and Sam are working on a hackathon project together, trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation. They seem to be working hard on this project and have a great idea for how the key-value store can help. Human: Sam is the founder of a company called Daimon. AI: That's impressive! It sounds like Sam is a very successful entrepreneur. What kind of company is Daimon? Human: Sam is the founder of a company called Daimon. AI: That's impressive! It sounds like Sam is a very successful entrepreneur. What kind of company is Daimon? Last line: Human: What do you know about Sam? You: > Finished chain. ' Sam is the founder of a successful company called Daimon. He is also working on a hackathon project with Deven to add more complex memory structures to Langchain. They seem to have a great idea for how the key-value store can help.'

https://python.langchain.com/docs/modules/data_connection/retrievers/parent_document_retriever/

## Parent Document Retriever When splitting documents for retrieval, there are often conflicting desires: 1. You may want to have small documents, so that their embeddings can most accurately reflect their meaning. If too long, then the embeddings can lose meaning. 2. You want to have long enough documents that the context of each chunk is retained. The `ParentDocumentRetriever` strikes that balance by splitting and storing small chunks of data. During retrieval, it first fetches the small chunks but then looks up the parent ids for those chunks and returns those larger documents. Note that “parent document” refers to the document that a small chunk originated from. This can either be the whole raw document OR a larger chunk. ``` from langchain.retrievers import ParentDocumentRetriever ``` ``` from langchain.storage import InMemoryStorefrom langchain_chroma import Chromafrom langchain_community.document_loaders import TextLoaderfrom langchain_openai import OpenAIEmbeddingsfrom langchain_text_splitters import RecursiveCharacterTextSplitter ``` ``` loaders = [ TextLoader("../../paul_graham_essay.txt"), TextLoader("../../state_of_the_union.txt"),]docs = []for loader in loaders: docs.extend(loader.load()) ``` ## Retrieving full documents[​](#retrieving-full-documents "Direct link to Retrieving full documents") In this mode, we want to retrieve the full documents. Therefore, we only specify a child splitter. ``` # This text splitter is used to create the child documentschild_splitter = RecursiveCharacterTextSplitter(chunk_size=400)# The vectorstore to use to index the child chunksvectorstore = Chroma( collection_name="full_documents", embedding_function=OpenAIEmbeddings())# The storage layer for the parent documentsstore = InMemoryStore()retriever = ParentDocumentRetriever( vectorstore=vectorstore, docstore=store, child_splitter=child_splitter,) ``` ``` retriever.add_documents(docs, ids=None) ``` This should yield two keys, because we added two documents. ``` ['cfdf4af7-51f2-4ea3-8166-5be208efa040', 'bf213c21-cc66-4208-8a72-733d030187e6'] ``` Let’s now call the vector store search functionality - we should see that it returns small chunks (since we’re storing the small chunks). ``` sub_docs = vectorstore.similarity_search("justice breyer") ``` ``` print(sub_docs[0].page_content) ``` ``` Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. ``` Let’s now retrieve from the overall retriever. This should return large documents - since it returns the documents where the smaller chunks are located. ``` retrieved_docs = retriever.get_relevant_documents("justice breyer") ``` ``` len(retrieved_docs[0].page_content) ``` ## Retrieving larger chunks[​](#retrieving-larger-chunks "Direct link to Retrieving larger chunks") Sometimes, the full documents can be too big to want to retrieve them as is. In that case, what we really want to do is to first split the raw documents into larger chunks, and then split it into smaller chunks. We then index the smaller chunks, but on retrieval we retrieve the larger chunks (but still not the full documents). ``` # This text splitter is used to create the parent documentsparent_splitter = RecursiveCharacterTextSplitter(chunk_size=2000)# This text splitter is used to create the child documents# It should create documents smaller than the parentchild_splitter = RecursiveCharacterTextSplitter(chunk_size=400)# The vectorstore to use to index the child chunksvectorstore = Chroma( collection_name="split_parents", embedding_function=OpenAIEmbeddings())# The storage layer for the parent documentsstore = InMemoryStore() ``` ``` retriever = ParentDocumentRetriever( vectorstore=vectorstore, docstore=store, child_splitter=child_splitter, parent_splitter=parent_splitter,) ``` ``` retriever.add_documents(docs) ``` We can see that there are much more than two documents now - these are the larger chunks. ``` len(list(store.yield_keys())) ``` Let’s make sure the underlying vector store still retrieves the small chunks. ``` sub_docs = vectorstore.similarity_search("justice breyer") ``` ``` print(sub_docs[0].page_content) ``` ``` Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. ``` ``` retrieved_docs = retriever.get_relevant_documents("justice breyer") ``` ``` len(retrieved_docs[0].page_content) ``` ``` print(retrieved_docs[0].page_content) ``` ``` In state after state, new laws have been passed, not only to suppress the vote, but to subvert entire elections. We cannot let this happen. Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. A former top litigator in private practice. A former federal public defender. And from a family of public school educators and police officers. A consensus builder. Since she’s been nominated, she’s received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans. And if we are to advance liberty and justice, we need to secure the Border and fix the immigration system. We can do both. At our border, we’ve installed new technology like cutting-edge scanners to better detect drug smuggling. We’ve set up joint patrols with Mexico and Guatemala to catch more human traffickers. We’re putting in place dedicated immigration judges so families fleeing persecution and violence can have their cases heard faster. We’re securing commitments and supporting partners in South and Central America to host more refugees and secure their own borders. ```

Parent Document Retriever When splitting documents for retrieval, there are often conflicting desires: You may want to have small documents, so that their embeddings can most accurately reflect their meaning. If too long, then the embeddings can lose meaning. You want to have long enough documents that the context of each chunk is retained. The ParentDocumentRetriever strikes that balance by splitting and storing small chunks of data. During retrieval, it first fetches the small chunks but then looks up the parent ids for those chunks and returns those larger documents. Note that “parent document” refers to the document that a small chunk originated from. This can either be the whole raw document OR a larger chunk. from langchain.retrievers import ParentDocumentRetriever from langchain.storage import InMemoryStore from langchain_chroma import Chroma from langchain_community.document_loaders import TextLoader from langchain_openai import OpenAIEmbeddings from langchain_text_splitters import RecursiveCharacterTextSplitter loaders = [ TextLoader("../../paul_graham_essay.txt"), TextLoader("../../state_of_the_union.txt"), ] docs = [] for loader in loaders: docs.extend(loader.load()) Retrieving full documents​ In this mode, we want to retrieve the full documents. Therefore, we only specify a child splitter. # This text splitter is used to create the child documents child_splitter = RecursiveCharacterTextSplitter(chunk_size=400) # The vectorstore to use to index the child chunks vectorstore = Chroma( collection_name="full_documents", embedding_function=OpenAIEmbeddings() ) # The storage layer for the parent documents store = InMemoryStore() retriever = ParentDocumentRetriever( vectorstore=vectorstore, docstore=store, child_splitter=child_splitter, ) retriever.add_documents(docs, ids=None) This should yield two keys, because we added two documents. ['cfdf4af7-51f2-4ea3-8166-5be208efa040', 'bf213c21-cc66-4208-8a72-733d030187e6'] Let’s now call the vector store search functionality - we should see that it returns small chunks (since we’re storing the small chunks). sub_docs = vectorstore.similarity_search("justice breyer") print(sub_docs[0].page_content) Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. Let’s now retrieve from the overall retriever. This should return large documents - since it returns the documents where the smaller chunks are located. retrieved_docs = retriever.get_relevant_documents("justice breyer") len(retrieved_docs[0].page_content) Retrieving larger chunks​ Sometimes, the full documents can be too big to want to retrieve them as is. In that case, what we really want to do is to first split the raw documents into larger chunks, and then split it into smaller chunks. We then index the smaller chunks, but on retrieval we retrieve the larger chunks (but still not the full documents). # This text splitter is used to create the parent documents parent_splitter = RecursiveCharacterTextSplitter(chunk_size=2000) # This text splitter is used to create the child documents # It should create documents smaller than the parent child_splitter = RecursiveCharacterTextSplitter(chunk_size=400) # The vectorstore to use to index the child chunks vectorstore = Chroma( collection_name="split_parents", embedding_function=OpenAIEmbeddings() ) # The storage layer for the parent documents store = InMemoryStore() retriever = ParentDocumentRetriever( vectorstore=vectorstore, docstore=store, child_splitter=child_splitter, parent_splitter=parent_splitter, ) retriever.add_documents(docs) We can see that there are much more than two documents now - these are the larger chunks. len(list(store.yield_keys())) Let’s make sure the underlying vector store still retrieves the small chunks. sub_docs = vectorstore.similarity_search("justice breyer") print(sub_docs[0].page_content) Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. retrieved_docs = retriever.get_relevant_documents("justice breyer") len(retrieved_docs[0].page_content) print(retrieved_docs[0].page_content) In state after state, new laws have been passed, not only to suppress the vote, but to subvert entire elections. We cannot let this happen. Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. A former top litigator in private practice. A former federal public defender. And from a family of public school educators and police officers. A consensus builder. Since she’s been nominated, she’s received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans. And if we are to advance liberty and justice, we need to secure the Border and fix the immigration system. We can do both. At our border, we’ve installed new technology like cutting-edge scanners to better detect drug smuggling. We’ve set up joint patrols with Mexico and Guatemala to catch more human traffickers. We’re putting in place dedicated immigration judges so families fleeing persecution and violence can have their cases heard faster. We’re securing commitments and supporting partners in South and Central America to host more refugees and secure their own borders.

https://python.langchain.com/docs/modules/data_connection/text_embedding/

## Text embedding models info Head to [Integrations](https://python.langchain.com/docs/integrations/text_embedding/) for documentation on built-in integrations with text embedding model providers. The Embeddings class is a class designed for interfacing with text embedding models. There are lots of embedding model providers (OpenAI, Cohere, Hugging Face, etc) - this class is designed to provide a standard interface for all of them. Embeddings create a vector representation of a piece of text. This is useful because it means we can think about text in the vector space, and do things like semantic search where we look for pieces of text that are most similar in the vector space. The base Embeddings class in LangChain provides two methods: one for embedding documents and one for embedding a query. The former takes as input multiple texts, while the latter takes a single text. The reason for having these as two separate methods is that some embedding providers have different embedding methods for documents (to be searched over) vs queries (the search query itself). ## Get started[​](#get-started "Direct link to Get started") ### Setup[​](#setup "Direct link to Setup") * OpenAI * Cohere To start we'll need to install the OpenAI partner package: ``` pip install langchain-openai ``` Accessing the API requires an API key, which you can get by creating an account and heading [here](https://platform.openai.com/account/api-keys). Once we have a key we'll want to set it as an environment variable by running: ``` export OPENAI_API_KEY="..." ``` If you'd prefer not to set an environment variable you can pass the key in directly via the `api_key` named parameter when initiating the OpenAI LLM class: ``` from langchain_openai import OpenAIEmbeddingsembeddings_model = OpenAIEmbeddings(api_key="...") ``` Otherwise you can initialize without any params: ``` from langchain_openai import OpenAIEmbeddingsembeddings_model = OpenAIEmbeddings() ``` ### `embed_documents`[​](#embed_documents "Direct link to embed_documents") #### Embed list of texts[​](#embed-list-of-texts "Direct link to Embed list of texts") ``` embeddings = embeddings_model.embed_documents( [ "Hi there!", "Oh, hello!", "What's your name?", "My friends call me World", "Hello World!" ])len(embeddings), len(embeddings[0]) ``` ### `embed_query`[​](#embed_query "Direct link to embed_query") #### Embed single query[​](#embed-single-query "Direct link to Embed single query") Embed a single piece of text for the purpose of comparing to other embedded pieces of texts. ``` embedded_query = embeddings_model.embed_query("What was the name mentioned in the conversation?")embedded_query[:5] ``` ``` [0.0053587136790156364, -0.0004999046213924885, 0.038883671164512634, -0.003001077566295862, -0.00900818221271038] ```

Text embedding models info Head to Integrations for documentation on built-in integrations with text embedding model providers. The Embeddings class is a class designed for interfacing with text embedding models. There are lots of embedding model providers (OpenAI, Cohere, Hugging Face, etc) - this class is designed to provide a standard interface for all of them. Embeddings create a vector representation of a piece of text. This is useful because it means we can think about text in the vector space, and do things like semantic search where we look for pieces of text that are most similar in the vector space. The base Embeddings class in LangChain provides two methods: one for embedding documents and one for embedding a query. The former takes as input multiple texts, while the latter takes a single text. The reason for having these as two separate methods is that some embedding providers have different embedding methods for documents (to be searched over) vs queries (the search query itself). Get started​ Setup​ OpenAI Cohere To start we'll need to install the OpenAI partner package: pip install langchain-openai Accessing the API requires an API key, which you can get by creating an account and heading here. Once we have a key we'll want to set it as an environment variable by running: export OPENAI_API_KEY="..." If you'd prefer not to set an environment variable you can pass the key in directly via the api_key named parameter when initiating the OpenAI LLM class: from langchain_openai import OpenAIEmbeddings embeddings_model = OpenAIEmbeddings(api_key="...") Otherwise you can initialize without any params: from langchain_openai import OpenAIEmbeddings embeddings_model = OpenAIEmbeddings() embed_documents​ Embed list of texts​ embeddings = embeddings_model.embed_documents( [ "Hi there!", "Oh, hello!", "What's your name?", "My friends call me World", "Hello World!" ] ) len(embeddings), len(embeddings[0]) embed_query​ Embed single query​ Embed a single piece of text for the purpose of comparing to other embedded pieces of texts. embedded_query = embeddings_model.embed_query("What was the name mentioned in the conversation?") embedded_query[:5] [0.0053587136790156364, -0.0004999046213924885, 0.038883671164512634, -0.003001077566295862, -0.00900818221271038]

https://python.langchain.com/docs/modules/memory/types/summary_buffer/

## Conversation Summary Buffer `ConversationSummaryBufferMemory` combines the two ideas. It keeps a buffer of recent interactions in memory, but rather than just completely flushing old interactions it compiles them into a summary and uses both. It uses token length rather than number of interactions to determine when to flush interactions. Let’s first walk through how to use the utilities. ## Using memory with LLM[​](#using-memory-with-llm "Direct link to Using memory with LLM") ``` from langchain.memory import ConversationSummaryBufferMemoryfrom langchain_openai import OpenAIllm = OpenAI() ``` ``` memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=10)memory.save_context({"input": "hi"}, {"output": "whats up"})memory.save_context({"input": "not much you"}, {"output": "not much"}) ``` ``` memory.load_memory_variables({}) ``` ``` {'history': 'System: \nThe human says "hi", and the AI responds with "whats up".\nHuman: not much you\nAI: not much'} ``` We can also get the history as a list of messages (this is useful if you are using this with a chat model). ``` memory = ConversationSummaryBufferMemory( llm=llm, max_token_limit=10, return_messages=True)memory.save_context({"input": "hi"}, {"output": "whats up"})memory.save_context({"input": "not much you"}, {"output": "not much"}) ``` We can also utilize the `predict_new_summary` method directly. ``` messages = memory.chat_memory.messagesprevious_summary = ""memory.predict_new_summary(messages, previous_summary) ``` ``` '\nThe human and AI state that they are not doing much.' ``` ## Using in a chain[​](#using-in-a-chain "Direct link to Using in a chain") Let’s walk through an example, again setting `verbose=True` so we can see the prompt. ``` from langchain.chains import ConversationChainconversation_with_summary = ConversationChain( llm=llm, # We set a very low max_token_limit for the purposes of testing. memory=ConversationSummaryBufferMemory(llm=OpenAI(), max_token_limit=40), verbose=True,)conversation_with_summary.predict(input="Hi, what's up?") ``` ``` > 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: Hi, what's up?AI:> Finished chain. ``` ``` " Hi there! I'm doing great. I'm learning about the latest advances in artificial intelligence. What about you?" ``` ``` conversation_with_summary.predict(input="Just working on writing some documentation!") ``` ``` > 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: Hi, what's up?AI: Hi there! I'm doing great. I'm spending some time learning about the latest developments in AI technology. How about you?Human: Just working on writing some documentation!AI:> Finished chain. ``` ``` ' That sounds like a great use of your time. Do you have experience with writing documentation?' ``` ``` # We can see here that there is a summary of the conversation and then some previous interactionsconversation_with_summary.predict(input="For LangChain! Have you heard of it?") ``` ``` > 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:System: The human asked the AI what it was up to and the AI responded that it was learning about the latest developments in AI technology.Human: Just working on writing some documentation!AI: That sounds like a great use of your time. Do you have experience with writing documentation?Human: For LangChain! Have you heard of it?AI:> Finished chain. ``` ``` " No, I haven't heard of LangChain. Can you tell me more about it?" ``` ``` # We can see here that the summary and the buffer are updatedconversation_with_summary.predict( input="Haha nope, although a lot of people confuse it for that") ``` ``` > 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:System: The human asked the AI what it was up to and the AI responded that it was learning about the latest developments in AI technology. The human then mentioned they were writing documentation, to which the AI responded that it sounded like a great use of their time and asked if they had experience with writing documentation.Human: For LangChain! Have you heard of it?AI: No, I haven't heard of LangChain. Can you tell me more about it?Human: Haha nope, although a lot of people confuse it for thatAI:> Finished chain. ``` ``` ' Oh, okay. What is LangChain?' ```

Conversation Summary Buffer ConversationSummaryBufferMemory combines the two ideas. It keeps a buffer of recent interactions in memory, but rather than just completely flushing old interactions it compiles them into a summary and uses both. It uses token length rather than number of interactions to determine when to flush interactions. Let’s first walk through how to use the utilities. Using memory with LLM​ from langchain.memory import ConversationSummaryBufferMemory from langchain_openai import OpenAI llm = OpenAI() memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=10) memory.save_context({"input": "hi"}, {"output": "whats up"}) memory.save_context({"input": "not much you"}, {"output": "not much"}) memory.load_memory_variables({}) {'history': 'System: \nThe human says "hi", and the AI responds with "whats up".\nHuman: not much you\nAI: not much'} We can also get the history as a list of messages (this is useful if you are using this with a chat model). memory = ConversationSummaryBufferMemory( llm=llm, max_token_limit=10, return_messages=True ) memory.save_context({"input": "hi"}, {"output": "whats up"}) memory.save_context({"input": "not much you"}, {"output": "not much"}) We can also utilize the predict_new_summary method directly. messages = memory.chat_memory.messages previous_summary = "" memory.predict_new_summary(messages, previous_summary) '\nThe human and AI state that they are not doing much.' Using in a chain​ Let’s walk through an example, again setting verbose=True so we can see the prompt. from langchain.chains import ConversationChain conversation_with_summary = ConversationChain( llm=llm, # We set a very low max_token_limit for the purposes of testing. memory=ConversationSummaryBufferMemory(llm=OpenAI(), max_token_limit=40), verbose=True, ) conversation_with_summary.predict(input="Hi, what's up?") > 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: Hi, what's up? AI: > Finished chain. " Hi there! I'm doing great. I'm learning about the latest advances in artificial intelligence. What about you?" conversation_with_summary.predict(input="Just working on writing some documentation!") > 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: Hi, what's up? AI: Hi there! I'm doing great. I'm spending some time learning about the latest developments in AI technology. How about you? Human: Just working on writing some documentation! AI: > Finished chain. ' That sounds like a great use of your time. Do you have experience with writing documentation?' # We can see here that there is a summary of the conversation and then some previous interactions conversation_with_summary.predict(input="For LangChain! Have you heard of it?") > 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: System: The human asked the AI what it was up to and the AI responded that it was learning about the latest developments in AI technology. Human: Just working on writing some documentation! AI: That sounds like a great use of your time. Do you have experience with writing documentation? Human: For LangChain! Have you heard of it? AI: > Finished chain. " No, I haven't heard of LangChain. Can you tell me more about it?" # We can see here that the summary and the buffer are updated conversation_with_summary.predict( input="Haha nope, although a lot of people confuse it for that" ) > 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: System: The human asked the AI what it was up to and the AI responded that it was learning about the latest developments in AI technology. The human then mentioned they were writing documentation, to which the AI responded that it sounded like a great use of their time and asked if they had experience with writing documentation. Human: For LangChain! Have you heard of it? AI: No, I haven't heard of LangChain. Can you tell me more about it? Human: Haha nope, although a lot of people confuse it for that AI: > Finished chain. ' Oh, okay. What is LangChain?'

https://python.langchain.com/docs/modules/data_connection/text_embedding/caching_embeddings/

## Caching Embeddings can be stored or temporarily cached to avoid needing to recompute them. Caching embeddings can be done using a `CacheBackedEmbeddings`. The cache backed embedder is a wrapper around an embedder that caches embeddings in a key-value store. The text is hashed and the hash is used as the key in the cache. The main supported way to initialize a `CacheBackedEmbeddings` is `from_bytes_store`. It takes the following parameters: * underlying\_embedder: The embedder to use for embedding. * document\_embedding\_cache: Any [`ByteStore`](https://python.langchain.com/docs/integrations/stores/) for caching document embeddings. * batch\_size: (optional, defaults to `None`) The number of documents to embed between store updates. * namespace: (optional, defaults to `""`) The namespace to use for document cache. This namespace is used to avoid collisions with other caches. For example, set it to the name of the embedding model used. **Attention**: * Be sure to set the `namespace` parameter to avoid collisions of the same text embedded using different embeddings models. * Currently `CacheBackedEmbeddings` does not cache embedding created with `embed_query()` `aembed_query()` methods. ``` from langchain.embeddings import CacheBackedEmbeddings ``` ## Using with a Vector Store[​](#using-with-a-vector-store "Direct link to Using with a Vector Store") First, let’s see an example that uses the local file system for storing embeddings and uses FAISS vector store for retrieval. ``` %pip install --upgrade --quiet langchain-openai faiss-cpu ``` ``` from langchain.storage import LocalFileStorefrom langchain_community.document_loaders import TextLoaderfrom langchain_community.vectorstores import FAISSfrom langchain_openai import OpenAIEmbeddingsfrom langchain_text_splitters import CharacterTextSplitterunderlying_embeddings = OpenAIEmbeddings()store = LocalFileStore("./cache/")cached_embedder = CacheBackedEmbeddings.from_bytes_store( underlying_embeddings, store, namespace=underlying_embeddings.model) ``` The cache is empty prior to embedding: Load the document, split it into chunks, embed each chunk and load it into the vector store. ``` raw_documents = TextLoader("../../state_of_the_union.txt").load()text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)documents = text_splitter.split_documents(raw_documents) ``` Create the vector store: ``` %%timedb = FAISS.from_documents(documents, cached_embedder) ``` ``` CPU times: user 218 ms, sys: 29.7 ms, total: 248 msWall time: 1.02 s ``` If we try to create the vector store again, it’ll be much faster since it does not need to re-compute any embeddings. ``` %%timedb2 = FAISS.from_documents(documents, cached_embedder) ``` ``` CPU times: user 15.7 ms, sys: 2.22 ms, total: 18 msWall time: 17.2 ms ``` And here are some of the embeddings that got created: ``` list(store.yield_keys())[:5] ``` ``` ['text-embedding-ada-00217a6727d-8916-54eb-b196-ec9c9d6ca472', 'text-embedding-ada-0025fc0d904-bd80-52da-95c9-441015bfb438', 'text-embedding-ada-002e4ad20ef-dfaa-5916-9459-f90c6d8e8159', 'text-embedding-ada-002ed199159-c1cd-5597-9757-f80498e8f17b', 'text-embedding-ada-0021297d37a-2bc1-5e19-bf13-6c950f075062'] ``` ## Swapping the `ByteStore` In order to use a different `ByteStore`, just use it when creating your `CacheBackedEmbeddings`. Below, we create an equivalent cached embeddings object, except using the non-persistent `InMemoryByteStore` instead: ``` from langchain.embeddings import CacheBackedEmbeddingsfrom langchain.storage import InMemoryByteStorestore = InMemoryByteStore()cached_embedder = CacheBackedEmbeddings.from_bytes_store( underlying_embeddings, store, namespace=underlying_embeddings.model) ``` * * * #### Help us out by providing feedback on this documentation page:

Caching Embeddings can be stored or temporarily cached to avoid needing to recompute them. Caching embeddings can be done using a CacheBackedEmbeddings. The cache backed embedder is a wrapper around an embedder that caches embeddings in a key-value store. The text is hashed and the hash is used as the key in the cache. The main supported way to initialize a CacheBackedEmbeddings is from_bytes_store. It takes the following parameters: underlying_embedder: The embedder to use for embedding. document_embedding_cache: Any ByteStore for caching document embeddings. batch_size: (optional, defaults to None) The number of documents to embed between store updates. namespace: (optional, defaults to "") The namespace to use for document cache. This namespace is used to avoid collisions with other caches. For example, set it to the name of the embedding model used. Attention: Be sure to set the namespace parameter to avoid collisions of the same text embedded using different embeddings models. Currently CacheBackedEmbeddings does not cache embedding created with embed_query() aembed_query() methods. from langchain.embeddings import CacheBackedEmbeddings Using with a Vector Store​ First, let’s see an example that uses the local file system for storing embeddings and uses FAISS vector store for retrieval. %pip install --upgrade --quiet langchain-openai faiss-cpu from langchain.storage import LocalFileStore from langchain_community.document_loaders import TextLoader from langchain_community.vectorstores import FAISS from langchain_openai import OpenAIEmbeddings from langchain_text_splitters import CharacterTextSplitter underlying_embeddings = OpenAIEmbeddings() store = LocalFileStore("./cache/") cached_embedder = CacheBackedEmbeddings.from_bytes_store( underlying_embeddings, store, namespace=underlying_embeddings.model ) The cache is empty prior to embedding: Load the document, split it into chunks, embed each chunk and load it into the vector store. raw_documents = TextLoader("../../state_of_the_union.txt").load() text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0) documents = text_splitter.split_documents(raw_documents) Create the vector store: %%time db = FAISS.from_documents(documents, cached_embedder) CPU times: user 218 ms, sys: 29.7 ms, total: 248 ms Wall time: 1.02 s If we try to create the vector store again, it’ll be much faster since it does not need to re-compute any embeddings. %%time db2 = FAISS.from_documents(documents, cached_embedder) CPU times: user 15.7 ms, sys: 2.22 ms, total: 18 ms Wall time: 17.2 ms And here are some of the embeddings that got created: list(store.yield_keys())[:5] ['text-embedding-ada-00217a6727d-8916-54eb-b196-ec9c9d6ca472', 'text-embedding-ada-0025fc0d904-bd80-52da-95c9-441015bfb438', 'text-embedding-ada-002e4ad20ef-dfaa-5916-9459-f90c6d8e8159', 'text-embedding-ada-002ed199159-c1cd-5597-9757-f80498e8f17b', 'text-embedding-ada-0021297d37a-2bc1-5e19-bf13-6c950f075062'] Swapping the ByteStore In order to use a different ByteStore, just use it when creating your CacheBackedEmbeddings. Below, we create an equivalent cached embeddings object, except using the non-persistent InMemoryByteStore instead: from langchain.embeddings import CacheBackedEmbeddings from langchain.storage import InMemoryByteStore store = InMemoryByteStore() cached_embedder = CacheBackedEmbeddings.from_bytes_store( underlying_embeddings, store, namespace=underlying_embeddings.model ) Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/modules/data_connection/retrievers/vectorstore/

## Vector store-backed retriever A vector store retriever is a retriever that uses a vector store to retrieve documents. It is a lightweight wrapper around the vector store class to make it conform to the retriever interface. It uses the search methods implemented by a vector store, like similarity search and MMR, to query the texts in the vector store. Once you construct a vector store, it’s very easy to construct a retriever. Let’s walk through an example. ``` from langchain_community.document_loaders import TextLoaderloader = TextLoader("../../state_of_the_union.txt") ``` ``` from langchain_community.vectorstores import FAISSfrom langchain_openai import OpenAIEmbeddingsfrom langchain_text_splitters import CharacterTextSplitterdocuments = loader.load()text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)texts = text_splitter.split_documents(documents)embeddings = OpenAIEmbeddings()db = FAISS.from_documents(texts, embeddings) ``` ``` retriever = db.as_retriever() ``` ``` docs = retriever.get_relevant_documents("what did he say about ketanji brown jackson") ``` ## Maximum marginal relevance retrieval[​](#maximum-marginal-relevance-retrieval "Direct link to Maximum marginal relevance retrieval") By default, the vector store retriever uses similarity search. If the underlying vector store supports maximum marginal relevance search, you can specify that as the search type. ``` retriever = db.as_retriever(search_type="mmr") ``` ``` docs = retriever.get_relevant_documents("what did he say about ketanji brown jackson") ``` ## Similarity score threshold retrieval[​](#similarity-score-threshold-retrieval "Direct link to Similarity score threshold retrieval") You can also set a retrieval method that sets a similarity score threshold and only returns documents with a score above that threshold. ``` retriever = db.as_retriever( search_type="similarity_score_threshold", search_kwargs={"score_threshold": 0.5}) ``` ``` docs = retriever.get_relevant_documents("what did he say about ketanji brown jackson") ``` ## Specifying top k[​](#specifying-top-k "Direct link to Specifying top k") You can also specify search kwargs like `k` to use when doing retrieval. ``` retriever = db.as_retriever(search_kwargs={"k": 1}) ``` ``` docs = retriever.get_relevant_documents("what did he say about ketanji brown jackson")len(docs) ```

Vector store-backed retriever A vector store retriever is a retriever that uses a vector store to retrieve documents. It is a lightweight wrapper around the vector store class to make it conform to the retriever interface. It uses the search methods implemented by a vector store, like similarity search and MMR, to query the texts in the vector store. Once you construct a vector store, it’s very easy to construct a retriever. Let’s walk through an example. from langchain_community.document_loaders import TextLoader loader = TextLoader("../../state_of_the_union.txt") from langchain_community.vectorstores import FAISS from langchain_openai import OpenAIEmbeddings from langchain_text_splitters import CharacterTextSplitter documents = loader.load() text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0) texts = text_splitter.split_documents(documents) embeddings = OpenAIEmbeddings() db = FAISS.from_documents(texts, embeddings) retriever = db.as_retriever() docs = retriever.get_relevant_documents("what did he say about ketanji brown jackson") Maximum marginal relevance retrieval​ By default, the vector store retriever uses similarity search. If the underlying vector store supports maximum marginal relevance search, you can specify that as the search type. retriever = db.as_retriever(search_type="mmr") docs = retriever.get_relevant_documents("what did he say about ketanji brown jackson") Similarity score threshold retrieval​ You can also set a retrieval method that sets a similarity score threshold and only returns documents with a score above that threshold. retriever = db.as_retriever( search_type="similarity_score_threshold", search_kwargs={"score_threshold": 0.5} ) docs = retriever.get_relevant_documents("what did he say about ketanji brown jackson") Specifying top k​ You can also specify search kwargs like k to use when doing retrieval. retriever = db.as_retriever(search_kwargs={"k": 1}) docs = retriever.get_relevant_documents("what did he say about ketanji brown jackson") len(docs)

https://python.langchain.com/docs/modules/memory/types/kg/

## Conversation Knowledge Graph This type of memory uses a knowledge graph to recreate memory. ## Using memory with LLM[​](#using-memory-with-llm "Direct link to Using memory with LLM") ``` from langchain.memory import ConversationKGMemoryfrom langchain_openai import OpenAI ``` ``` llm = OpenAI(temperature=0)memory = ConversationKGMemory(llm=llm)memory.save_context({"input": "say hi to sam"}, {"output": "who is sam"})memory.save_context({"input": "sam is a friend"}, {"output": "okay"}) ``` ``` memory.load_memory_variables({"input": "who is sam"}) ``` ``` {'history': 'On Sam: Sam is friend.'} ``` We can also get the history as a list of messages (this is useful if you are using this with a chat model). ``` memory = ConversationKGMemory(llm=llm, return_messages=True)memory.save_context({"input": "say hi to sam"}, {"output": "who is sam"})memory.save_context({"input": "sam is a friend"}, {"output": "okay"}) ``` ``` memory.load_memory_variables({"input": "who is sam"}) ``` ``` {'history': [SystemMessage(content='On Sam: Sam is friend.', additional_kwargs={})]} ``` We can also more modularly get current entities from a new message (will use previous messages as context). ``` memory.get_current_entities("what's Sams favorite color?") ``` We can also more modularly get knowledge triplets from a new message (will use previous messages as context). ``` memory.get_knowledge_triplets("her favorite color is red") ``` ``` [KnowledgeTriple(subject='Sam', predicate='favorite color', object_='red')] ``` ## Using in a chain[​](#using-in-a-chain "Direct link to Using in a chain") Let’s now use this in a chain! ``` llm = OpenAI(temperature=0)from langchain.chains import ConversationChainfrom langchain_core.prompts.prompt import PromptTemplatetemplate = """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. The AI ONLY uses information contained in the "Relevant Information" section and does not hallucinate.Relevant Information:{history}Conversation:Human: {input}AI:"""prompt = PromptTemplate(input_variables=["history", "input"], template=template)conversation_with_kg = ConversationChain( llm=llm, verbose=True, prompt=prompt, memory=ConversationKGMemory(llm=llm)) ``` ``` conversation_with_kg.predict(input="Hi, what's up?") ``` ``` > 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. The AI ONLY uses information contained in the "Relevant Information" section and does not hallucinate.Relevant Information:Conversation:Human: Hi, what's up?AI:> Finished chain. ``` ``` " Hi there! I'm doing great. I'm currently in the process of learning about the world around me. I'm learning about different cultures, languages, and customs. It's really fascinating! How about you?" ``` ``` conversation_with_kg.predict( input="My name is James and I'm helping Will. He's an engineer.") ``` ``` > 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. The AI ONLY uses information contained in the "Relevant Information" section and does not hallucinate.Relevant Information:Conversation:Human: My name is James and I'm helping Will. He's an engineer.AI:> Finished chain. ``` ``` " Hi James, it's nice to meet you. I'm an AI and I understand you're helping Will, the engineer. What kind of engineering does he do?" ``` ``` conversation_with_kg.predict(input="What do you know about Will?") ``` ``` > 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. The AI ONLY uses information contained in the "Relevant Information" section and does not hallucinate.Relevant Information:On Will: Will is an engineer.Conversation:Human: What do you know about Will?AI:> Finished chain. ```

Conversation Knowledge Graph This type of memory uses a knowledge graph to recreate memory. Using memory with LLM​ from langchain.memory import ConversationKGMemory from langchain_openai import OpenAI llm = OpenAI(temperature=0) memory = ConversationKGMemory(llm=llm) memory.save_context({"input": "say hi to sam"}, {"output": "who is sam"}) memory.save_context({"input": "sam is a friend"}, {"output": "okay"}) memory.load_memory_variables({"input": "who is sam"}) {'history': 'On Sam: Sam is friend.'} We can also get the history as a list of messages (this is useful if you are using this with a chat model). memory = ConversationKGMemory(llm=llm, return_messages=True) memory.save_context({"input": "say hi to sam"}, {"output": "who is sam"}) memory.save_context({"input": "sam is a friend"}, {"output": "okay"}) memory.load_memory_variables({"input": "who is sam"}) {'history': [SystemMessage(content='On Sam: Sam is friend.', additional_kwargs={})]} We can also more modularly get current entities from a new message (will use previous messages as context). memory.get_current_entities("what's Sams favorite color?") We can also more modularly get knowledge triplets from a new message (will use previous messages as context). memory.get_knowledge_triplets("her favorite color is red") [KnowledgeTriple(subject='Sam', predicate='favorite color', object_='red')] Using in a chain​ Let’s now use this in a chain! llm = OpenAI(temperature=0) from langchain.chains import ConversationChain from langchain_core.prompts.prompt import PromptTemplate template = """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. The AI ONLY uses information contained in the "Relevant Information" section and does not hallucinate. Relevant Information: {history} Conversation: Human: {input} AI:""" prompt = PromptTemplate(input_variables=["history", "input"], template=template) conversation_with_kg = ConversationChain( llm=llm, verbose=True, prompt=prompt, memory=ConversationKGMemory(llm=llm) ) conversation_with_kg.predict(input="Hi, what's up?") > 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. The AI ONLY uses information contained in the "Relevant Information" section and does not hallucinate. Relevant Information: Conversation: Human: Hi, what's up? AI: > Finished chain. " Hi there! I'm doing great. I'm currently in the process of learning about the world around me. I'm learning about different cultures, languages, and customs. It's really fascinating! How about you?" conversation_with_kg.predict( input="My name is James and I'm helping Will. He's an engineer." ) > 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. The AI ONLY uses information contained in the "Relevant Information" section and does not hallucinate. Relevant Information: Conversation: Human: My name is James and I'm helping Will. He's an engineer. AI: > Finished chain. " Hi James, it's nice to meet you. I'm an AI and I understand you're helping Will, the engineer. What kind of engineering does he do?" conversation_with_kg.predict(input="What do you know about Will?") > 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. The AI ONLY uses information contained in the "Relevant Information" section and does not hallucinate. Relevant Information: On Will: Will is an engineer. Conversation: Human: What do you know about Will? AI: > Finished chain.

https://python.langchain.com/docs/modules/memory/types/summary/

## Conversation Summary Now let's take a look at using a slightly more complex type of memory - `ConversationSummaryMemory`. This type of memory creates a summary of the conversation over time. This can be useful for condensing information from the conversation over time. Conversation summary memory summarizes the conversation as it happens and stores the current summary in memory. This memory can then be used to inject the summary of the conversation so far into a prompt/chain. This memory is most useful for longer conversations, where keeping the past message history in the prompt verbatim would take up too many tokens. Let's first explore the basic functionality of this type of memory. ``` from langchain.memory import ConversationSummaryMemory, ChatMessageHistoryfrom langchain_openai import OpenAI ``` ``` memory = ConversationSummaryMemory(llm=OpenAI(temperature=0))memory.save_context({"input": "hi"}, {"output": "whats up"}) ``` ``` memory.load_memory_variables({}) ``` ``` {'history': '\nThe human greets the AI, to which the AI responds.'} ``` We can also get the history as a list of messages (this is useful if you are using this with a chat model). ``` memory = ConversationSummaryMemory(llm=OpenAI(temperature=0), return_messages=True)memory.save_context({"input": "hi"}, {"output": "whats up"}) ``` ``` memory.load_memory_variables({}) ``` ``` {'history': [SystemMessage(content='\nThe human greets the AI, to which the AI responds.', additional_kwargs={})]} ``` We can also utilize the `predict_new_summary` method directly. ``` messages = memory.chat_memory.messagesprevious_summary = ""memory.predict_new_summary(messages, previous_summary) ``` ``` '\nThe human greets the AI, to which the AI responds.' ``` ## Initializing with messages/existing summary[​](#initializing-with-messagesexisting-summary "Direct link to Initializing with messages/existing summary") If you have messages outside this class, you can easily initialize the class with `ChatMessageHistory`. During loading, a summary will be calculated. ``` history = ChatMessageHistory()history.add_user_message("hi")history.add_ai_message("hi there!") ``` ``` memory = ConversationSummaryMemory.from_messages( llm=OpenAI(temperature=0), chat_memory=history, return_messages=True) ``` ``` '\nThe human greets the AI, to which the AI responds with a friendly greeting.' ``` Optionally you can speed up initialization using a previously generated summary, and avoid regenerating the summary by just initializing directly. ``` memory = ConversationSummaryMemory( llm=OpenAI(temperature=0), buffer="The human asks what the AI thinks of artificial intelligence. The AI thinks artificial intelligence is a force for good because it will help humans reach their full potential.", chat_memory=history, return_messages=True) ``` ## Using in a chain[​](#using-in-a-chain "Direct link to Using in a chain") Let's walk through an example of using this in a chain, again setting `verbose=True` so we can see the prompt. ``` from langchain_openai import OpenAIfrom langchain.chains import ConversationChainllm = OpenAI(temperature=0)conversation_with_summary = ConversationChain( llm=llm, memory=ConversationSummaryMemory(llm=OpenAI()), verbose=True)conversation_with_summary.predict(input="Hi, what's up?") ``` ``` > 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: Hi, what's up? AI: > Finished chain. " Hi there! I'm doing great. I'm currently helping a customer with a technical issue. How about you?" ``` ``` conversation_with_summary.predict(input="Tell me more about it!") ``` ``` > 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: The human greeted the AI and asked how it was doing. The AI replied that it was doing great and was currently helping a customer with a technical issue. Human: Tell me more about it! AI: > Finished chain. " Sure! The customer is having trouble with their computer not connecting to the internet. I'm helping them troubleshoot the issue and figure out what the problem is. So far, we've tried resetting the router and checking the network settings, but the issue still persists. We're currently looking into other possible solutions." ``` ``` conversation_with_summary.predict(input="Very cool -- what is the scope of the project?") ``` ``` > 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: The human greeted the AI and asked how it was doing. The AI replied that it was doing great and was currently helping a customer with a technical issue where their computer was not connecting to the internet. The AI was troubleshooting the issue and had already tried resetting the router and checking the network settings, but the issue still persisted and they were looking into other possible solutions. Human: Very cool -- what is the scope of the project? AI: > Finished chain. " The scope of the project is to troubleshoot the customer's computer issue and find a solution that will allow them to connect to the internet. We are currently exploring different possibilities and have already tried resetting the router and checking the network settings, but the issue still persists." ``` * * * #### Help us out by providing feedback on this documentation page:

Conversation Summary Now let's take a look at using a slightly more complex type of memory - ConversationSummaryMemory. This type of memory creates a summary of the conversation over time. This can be useful for condensing information from the conversation over time. Conversation summary memory summarizes the conversation as it happens and stores the current summary in memory. This memory can then be used to inject the summary of the conversation so far into a prompt/chain. This memory is most useful for longer conversations, where keeping the past message history in the prompt verbatim would take up too many tokens. Let's first explore the basic functionality of this type of memory. from langchain.memory import ConversationSummaryMemory, ChatMessageHistory from langchain_openai import OpenAI memory = ConversationSummaryMemory(llm=OpenAI(temperature=0)) memory.save_context({"input": "hi"}, {"output": "whats up"}) memory.load_memory_variables({}) {'history': '\nThe human greets the AI, to which the AI responds.'} We can also get the history as a list of messages (this is useful if you are using this with a chat model). memory = ConversationSummaryMemory(llm=OpenAI(temperature=0), return_messages=True) memory.save_context({"input": "hi"}, {"output": "whats up"}) memory.load_memory_variables({}) {'history': [SystemMessage(content='\nThe human greets the AI, to which the AI responds.', additional_kwargs={})]} We can also utilize the predict_new_summary method directly. messages = memory.chat_memory.messages previous_summary = "" memory.predict_new_summary(messages, previous_summary) '\nThe human greets the AI, to which the AI responds.' Initializing with messages/existing summary​ If you have messages outside this class, you can easily initialize the class with ChatMessageHistory. During loading, a summary will be calculated. history = ChatMessageHistory() history.add_user_message("hi") history.add_ai_message("hi there!") memory = ConversationSummaryMemory.from_messages( llm=OpenAI(temperature=0), chat_memory=history, return_messages=True ) '\nThe human greets the AI, to which the AI responds with a friendly greeting.' Optionally you can speed up initialization using a previously generated summary, and avoid regenerating the summary by just initializing directly. memory = ConversationSummaryMemory( llm=OpenAI(temperature=0), buffer="The human asks what the AI thinks of artificial intelligence. The AI thinks artificial intelligence is a force for good because it will help humans reach their full potential.", chat_memory=history, return_messages=True ) Using in a chain​ Let's walk through an example of using this in a chain, again setting verbose=True so we can see the prompt. from langchain_openai import OpenAI from langchain.chains import ConversationChain llm = OpenAI(temperature=0) conversation_with_summary = ConversationChain( llm=llm, memory=ConversationSummaryMemory(llm=OpenAI()), verbose=True ) conversation_with_summary.predict(input="Hi, what's up?") > 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: Hi, what's up? AI: > Finished chain. " Hi there! I'm doing great. I'm currently helping a customer with a technical issue. How about you?" conversation_with_summary.predict(input="Tell me more about it!") > 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: The human greeted the AI and asked how it was doing. The AI replied that it was doing great and was currently helping a customer with a technical issue. Human: Tell me more about it! AI: > Finished chain. " Sure! The customer is having trouble with their computer not connecting to the internet. I'm helping them troubleshoot the issue and figure out what the problem is. So far, we've tried resetting the router and checking the network settings, but the issue still persists. We're currently looking into other possible solutions." conversation_with_summary.predict(input="Very cool -- what is the scope of the project?") > 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: The human greeted the AI and asked how it was doing. The AI replied that it was doing great and was currently helping a customer with a technical issue where their computer was not connecting to the internet. The AI was troubleshooting the issue and had already tried resetting the router and checking the network settings, but the issue still persisted and they were looking into other possible solutions. Human: Very cool -- what is the scope of the project? AI: > Finished chain. " The scope of the project is to troubleshoot the customer's computer issue and find a solution that will allow them to connect to the internet. We are currently exploring different possibilities and have already tried resetting the router and checking the network settings, but the issue still persists." Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/modules/data_connection/vectorstores/

## Vector stores info Head to [Integrations](https://python.langchain.com/docs/integrations/vectorstores/) for documentation on built-in integrations with 3rd-party vector stores. One of the most common ways to store and search over unstructured data is to embed it and store the resulting embedding vectors, and then at query time to embed the unstructured query and retrieve the embedding vectors that are 'most similar' to the embedded query. A vector store takes care of storing embedded data and performing vector search for you.  ## Get started[​](#get-started "Direct link to Get started") This walkthrough showcases basic functionality related to vector stores. A key part of working with vector stores is creating the vector to put in them, which is usually created via embeddings. Therefore, it is recommended that you familiarize yourself with the [text embedding model](https://python.langchain.com/docs/modules/data_connection/text_embedding/) interfaces before diving into this. There are many great vector store options, here are a few that are free, open-source, and run entirely on your local machine. Review all integrations for many great hosted offerings. * Chroma * FAISS * Lance This walkthrough uses the `chroma` vector database, which runs on your local machine as a library. ``` pip install langchain-chroma ``` We want to use OpenAIEmbeddings so we have to get the OpenAI API Key. ``` import osimport getpassos.environ['OPENAI_API_KEY'] = getpass.getpass('OpenAI API Key:') ``` ``` from langchain_community.document_loaders import TextLoaderfrom langchain_openai import OpenAIEmbeddingsfrom langchain_text_splitters import CharacterTextSplitterfrom langchain_chroma import Chroma# Load the document, split it into chunks, embed each chunk and load it into the vector store.raw_documents = TextLoader('../../../state_of_the_union.txt').load()text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)documents = text_splitter.split_documents(raw_documents)db = Chroma.from_documents(documents, OpenAIEmbeddings()) ``` ### Similarity search[​](#similarity-search "Direct link to Similarity search") ``` query = "What did the president say about Ketanji Brown Jackson"docs = db.similarity_search(query)print(docs[0].page_content) ``` ``` Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. ``` ### Similarity search by vector[​](#similarity-search-by-vector "Direct link to Similarity search by vector") It is also possible to do a search for documents similar to a given embedding vector using `similarity_search_by_vector` which accepts an embedding vector as a parameter instead of a string. ``` embedding_vector = OpenAIEmbeddings().embed_query(query)docs = db.similarity_search_by_vector(embedding_vector)print(docs[0].page_content) ``` The query is the same, and so the result is also the same. ``` Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. ``` ## Asynchronous operations[​](#asynchronous-operations "Direct link to Asynchronous operations") Vector stores are usually run as a separate service that requires some IO operations, and therefore they might be called asynchronously. That gives performance benefits as you don't waste time waiting for responses from external services. That might also be important if you work with an asynchronous framework, such as [FastAPI](https://fastapi.tiangolo.com/). LangChain supports async operation on vector stores. All the methods might be called using their async counterparts, with the prefix `a`, meaning `async`. `Qdrant` is a vector store, which supports all the async operations, thus it will be used in this walkthrough. ``` pip install qdrant-client ``` ``` from langchain_community.vectorstores import Qdrant ``` ### Create a vector store asynchronously[​](#create-a-vector-store-asynchronously "Direct link to Create a vector store asynchronously") ``` db = await Qdrant.afrom_documents(documents, embeddings, "http://localhost:6333") ``` ### Similarity search[​](#similarity-search-1 "Direct link to Similarity search") ``` query = "What did the president say about Ketanji Brown Jackson"docs = await db.asimilarity_search(query)print(docs[0].page_content) ``` ``` Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. ``` ### Similarity search by vector[​](#similarity-search-by-vector-1 "Direct link to Similarity search by vector") ``` embedding_vector = embeddings.embed_query(query)docs = await db.asimilarity_search_by_vector(embedding_vector) ``` ## Maximum marginal relevance search (MMR)[​](#maximum-marginal-relevance-search-mmr "Direct link to Maximum marginal relevance search (MMR)") Maximal marginal relevance optimizes for similarity to query **and** diversity among selected documents. It is also supported in async API. ``` query = "What did the president say about Ketanji Brown Jackson"found_docs = await qdrant.amax_marginal_relevance_search(query, k=2, fetch_k=10)for i, doc in enumerate(found_docs): print(f"{i + 1}.", doc.page_content, "\n") ``` ``` 1. Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections.Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service.One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court.And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.2. We can’t change how divided we’ve been. But we can change how we move forward—on COVID-19 and other issues we must face together.I recently visited the New York City Police Department days after the funerals of Officer Wilbert Mora and his partner, Officer Jason Rivera.They were responding to a 9-1-1 call when a man shot and killed them with a stolen gun.Officer Mora was 27 years old.Officer Rivera was 22.Both Dominican Americans who’d grown up on the same streets they later chose to patrol as police officers.I spoke with their families and told them that we are forever in debt for their sacrifice, and we will carry on their mission to restore the trust and safety every community deserves.I’ve worked on these issues a long time.I know what works: Investing in crime prevention and community police officers who’ll walk the beat, who’ll know the neighborhood, and who can restore trust and safety. ```

Vector stores info Head to Integrations for documentation on built-in integrations with 3rd-party vector stores. One of the most common ways to store and search over unstructured data is to embed it and store the resulting embedding vectors, and then at query time to embed the unstructured query and retrieve the embedding vectors that are 'most similar' to the embedded query. A vector store takes care of storing embedded data and performing vector search for you. Get started​ This walkthrough showcases basic functionality related to vector stores. A key part of working with vector stores is creating the vector to put in them, which is usually created via embeddings. Therefore, it is recommended that you familiarize yourself with the text embedding model interfaces before diving into this. There are many great vector store options, here are a few that are free, open-source, and run entirely on your local machine. Review all integrations for many great hosted offerings. Chroma FAISS Lance This walkthrough uses the chroma vector database, which runs on your local machine as a library. pip install langchain-chroma We want to use OpenAIEmbeddings so we have to get the OpenAI API Key. import os import getpass os.environ['OPENAI_API_KEY'] = getpass.getpass('OpenAI API Key:') from langchain_community.document_loaders import TextLoader from langchain_openai import OpenAIEmbeddings from langchain_text_splitters import CharacterTextSplitter from langchain_chroma import Chroma # Load the document, split it into chunks, embed each chunk and load it into the vector store. raw_documents = TextLoader('../../../state_of_the_union.txt').load() text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0) documents = text_splitter.split_documents(raw_documents) db = Chroma.from_documents(documents, OpenAIEmbeddings()) Similarity search​ query = "What did the president say about Ketanji Brown Jackson" docs = db.similarity_search(query) print(docs[0].page_content) Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. Similarity search by vector​ It is also possible to do a search for documents similar to a given embedding vector using similarity_search_by_vector which accepts an embedding vector as a parameter instead of a string. embedding_vector = OpenAIEmbeddings().embed_query(query) docs = db.similarity_search_by_vector(embedding_vector) print(docs[0].page_content) The query is the same, and so the result is also the same. Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. Asynchronous operations​ Vector stores are usually run as a separate service that requires some IO operations, and therefore they might be called asynchronously. That gives performance benefits as you don't waste time waiting for responses from external services. That might also be important if you work with an asynchronous framework, such as FastAPI. LangChain supports async operation on vector stores. All the methods might be called using their async counterparts, with the prefix a, meaning async. Qdrant is a vector store, which supports all the async operations, thus it will be used in this walkthrough. pip install qdrant-client from langchain_community.vectorstores import Qdrant Create a vector store asynchronously​ db = await Qdrant.afrom_documents(documents, embeddings, "http://localhost:6333") Similarity search​ query = "What did the president say about Ketanji Brown Jackson" docs = await db.asimilarity_search(query) print(docs[0].page_content) Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. Similarity search by vector​ embedding_vector = embeddings.embed_query(query) docs = await db.asimilarity_search_by_vector(embedding_vector) Maximum marginal relevance search (MMR)​ Maximal marginal relevance optimizes for similarity to query and diversity among selected documents. It is also supported in async API. query = "What did the president say about Ketanji Brown Jackson" found_docs = await qdrant.amax_marginal_relevance_search(query, k=2, fetch_k=10) for i, doc in enumerate(found_docs): print(f"{i + 1}.", doc.page_content, "\n") 1. Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. 2. We can’t change how divided we’ve been. But we can change how we move forward—on COVID-19 and other issues we must face together. I recently visited the New York City Police Department days after the funerals of Officer Wilbert Mora and his partner, Officer Jason Rivera. They were responding to a 9-1-1 call when a man shot and killed them with a stolen gun. Officer Mora was 27 years old. Officer Rivera was 22. Both Dominican Americans who’d grown up on the same streets they later chose to patrol as police officers. I spoke with their families and told them that we are forever in debt for their sacrifice, and we will carry on their mission to restore the trust and safety every community deserves. I’ve worked on these issues a long time. I know what works: Investing in crime prevention and community police officers who’ll walk the beat, who’ll know the neighborhood, and who can restore trust and safety.

https://python.langchain.com/docs/modules/memory/types/vectorstore_retriever_memory/

`VectorStoreRetrieverMemory` stores memories in a vector store and queries the top-K most "salient" docs every time it is called. This differs from most of the other Memory classes in that it doesn't explicitly track the order of interactions. In this case, the "docs" are previous conversation snippets. This can be useful to refer to relevant pieces of information that the AI was told earlier in the conversation. ``` from datetime import datetimefrom langchain_openai import OpenAIEmbeddingsfrom langchain_openai import OpenAIfrom langchain.memory import VectorStoreRetrieverMemoryfrom langchain.chains import ConversationChainfrom langchain_core.prompts import PromptTemplate ``` ### Initialize your vector store[​](#initialize-your-vector-store "Direct link to Initialize your vector store") Depending on the store you choose, this step may look different. Consult the relevant vector store documentation for more details. ``` import faissfrom langchain_community.docstore import InMemoryDocstorefrom langchain_community.vectorstores import FAISSembedding_size = 1536 # Dimensions of the OpenAIEmbeddingsindex = faiss.IndexFlatL2(embedding_size)embedding_fn = OpenAIEmbeddings().embed_queryvectorstore = FAISS(embedding_fn, index, InMemoryDocstore({}), {}) ``` ### Create your `VectorStoreRetrieverMemory`[​](#create-your-vectorstoreretrievermemory "Direct link to create-your-vectorstoreretrievermemory") The memory object is instantiated from any vector store retriever. ``` # In actual usage, you would set `k` to be a higher value, but we use k=1 to show that# the vector lookup still returns the semantically relevant informationretriever = vectorstore.as_retriever(search_kwargs=dict(k=1))memory = VectorStoreRetrieverMemory(retriever=retriever)# When added to an agent, the memory object can save pertinent information from conversations or used toolsmemory.save_context({"input": "My favorite food is pizza"}, {"output": "that's good to know"})memory.save_context({"input": "My favorite sport is soccer"}, {"output": "..."})memory.save_context({"input": "I don't the Celtics"}, {"output": "ok"}) # ``` ``` print(memory.load_memory_variables({"prompt": "what sport should i watch?"})["history"]) ``` ``` input: My favorite sport is soccer output: ... ``` ## Using in a chain[​](#using-in-a-chain "Direct link to Using in a chain") Let's walk through an example, again setting `verbose=True` so we can see the prompt. ``` llm = OpenAI(temperature=0) # Can be any valid LLM_DEFAULT_TEMPLATE = """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.Relevant pieces of previous conversation:{history}(You do not need to use these pieces of information if not relevant)Current conversation:Human: {input}AI:"""PROMPT = PromptTemplate( input_variables=["history", "input"], template=_DEFAULT_TEMPLATE)conversation_with_summary = ConversationChain( llm=llm, prompt=PROMPT, memory=memory, verbose=True)conversation_with_summary.predict(input="Hi, my name is Perry, what's up?") ``` ``` > 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. Relevant pieces of previous conversation: input: My favorite food is pizza output: that's good to know (You do not need to use these pieces of information if not relevant) Current conversation: Human: Hi, my name is Perry, what's up? AI: > Finished chain. " Hi Perry, I'm doing well. How about you?" ``` ``` # Here, the basketball related content is surfacedconversation_with_summary.predict(input="what's my favorite sport?") ``` ``` > 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. Relevant pieces of previous conversation: input: My favorite sport is soccer output: ... (You do not need to use these pieces of information if not relevant) Current conversation: Human: what's my favorite sport? AI: > Finished chain. ' You told me earlier that your favorite sport is soccer.' ``` ``` # Even though the language model is stateless, since relevant memory is fetched, it can "reason" about the time.# Timestamping memories and data is useful in general to let the agent determine temporal relevanceconversation_with_summary.predict(input="Whats my favorite food") ``` ``` > 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. Relevant pieces of previous conversation: input: My favorite food is pizza output: that's good to know (You do not need to use these pieces of information if not relevant) Current conversation: Human: Whats my favorite food AI: > Finished chain. ' You said your favorite food is pizza.' ``` ``` # The memories from the conversation are automatically stored,# since this query best matches the introduction chat above,# the agent is able to 'remember' the user's name.conversation_with_summary.predict(input="What's my name?") ``` ``` > 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. Relevant pieces of previous conversation: input: Hi, my name is Perry, what's up? response: Hi Perry, I'm doing well. How about you? (You do not need to use these pieces of information if not relevant) Current conversation: Human: What's my name? AI: > Finished chain. ' Your name is Perry.' ```

VectorStoreRetrieverMemory stores memories in a vector store and queries the top-K most "salient" docs every time it is called. This differs from most of the other Memory classes in that it doesn't explicitly track the order of interactions. In this case, the "docs" are previous conversation snippets. This can be useful to refer to relevant pieces of information that the AI was told earlier in the conversation. from datetime import datetime from langchain_openai import OpenAIEmbeddings from langchain_openai import OpenAI from langchain.memory import VectorStoreRetrieverMemory from langchain.chains import ConversationChain from langchain_core.prompts import PromptTemplate Initialize your vector store​ Depending on the store you choose, this step may look different. Consult the relevant vector store documentation for more details. import faiss from langchain_community.docstore import InMemoryDocstore from langchain_community.vectorstores import FAISS embedding_size = 1536 # Dimensions of the OpenAIEmbeddings index = faiss.IndexFlatL2(embedding_size) embedding_fn = OpenAIEmbeddings().embed_query vectorstore = FAISS(embedding_fn, index, InMemoryDocstore({}), {}) Create your VectorStoreRetrieverMemory​ The memory object is instantiated from any vector store retriever. # In actual usage, you would set `k` to be a higher value, but we use k=1 to show that # the vector lookup still returns the semantically relevant information retriever = vectorstore.as_retriever(search_kwargs=dict(k=1)) memory = VectorStoreRetrieverMemory(retriever=retriever) # When added to an agent, the memory object can save pertinent information from conversations or used tools memory.save_context({"input": "My favorite food is pizza"}, {"output": "that's good to know"}) memory.save_context({"input": "My favorite sport is soccer"}, {"output": "..."}) memory.save_context({"input": "I don't the Celtics"}, {"output": "ok"}) # print(memory.load_memory_variables({"prompt": "what sport should i watch?"})["history"]) input: My favorite sport is soccer output: ... Using in a chain​ Let's walk through an example, again setting verbose=True so we can see the prompt. llm = OpenAI(temperature=0) # Can be any valid LLM _DEFAULT_TEMPLATE = """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. Relevant pieces of previous conversation: {history} (You do not need to use these pieces of information if not relevant) Current conversation: Human: {input} AI:""" PROMPT = PromptTemplate( input_variables=["history", "input"], template=_DEFAULT_TEMPLATE ) conversation_with_summary = ConversationChain( llm=llm, prompt=PROMPT, memory=memory, verbose=True ) conversation_with_summary.predict(input="Hi, my name is Perry, what's up?") > 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. Relevant pieces of previous conversation: input: My favorite food is pizza output: that's good to know (You do not need to use these pieces of information if not relevant) Current conversation: Human: Hi, my name is Perry, what's up? AI: > Finished chain. " Hi Perry, I'm doing well. How about you?" # Here, the basketball related content is surfaced conversation_with_summary.predict(input="what's my favorite sport?") > 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. Relevant pieces of previous conversation: input: My favorite sport is soccer output: ... (You do not need to use these pieces of information if not relevant) Current conversation: Human: what's my favorite sport? AI: > Finished chain. ' You told me earlier that your favorite sport is soccer.' # Even though the language model is stateless, since relevant memory is fetched, it can "reason" about the time. # Timestamping memories and data is useful in general to let the agent determine temporal relevance conversation_with_summary.predict(input="Whats my favorite food") > 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. Relevant pieces of previous conversation: input: My favorite food is pizza output: that's good to know (You do not need to use these pieces of information if not relevant) Current conversation: Human: Whats my favorite food AI: > Finished chain. ' You said your favorite food is pizza.' # The memories from the conversation are automatically stored, # since this query best matches the introduction chat above, # the agent is able to 'remember' the user's name. conversation_with_summary.predict(input="What's my name?") > 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. Relevant pieces of previous conversation: input: Hi, my name is Perry, what's up? response: Hi Perry, I'm doing well. How about you? (You do not need to use these pieces of information if not relevant) Current conversation: Human: What's my name? AI: > Finished chain. ' Your name is Perry.'

https://python.langchain.com/docs/modules/memory/types/token_buffer/

## Conversation Token Buffer `ConversationTokenBufferMemory` keeps a buffer of recent interactions in memory, and uses token length rather than number of interactions to determine when to flush interactions. Let’s first walk through how to use the utilities. ## Using memory with LLM[​](#using-memory-with-llm "Direct link to Using memory with LLM") ``` from langchain.memory import ConversationTokenBufferMemoryfrom langchain_openai import OpenAIllm = OpenAI() ``` ``` memory = ConversationTokenBufferMemory(llm=llm, max_token_limit=10)memory.save_context({"input": "hi"}, {"output": "whats up"})memory.save_context({"input": "not much you"}, {"output": "not much"}) ``` ``` memory.load_memory_variables({}) ``` ``` {'history': 'Human: not much you\nAI: not much'} ``` We can also get the history as a list of messages (this is useful if you are using this with a chat model). ``` memory = ConversationTokenBufferMemory( llm=llm, max_token_limit=10, return_messages=True)memory.save_context({"input": "hi"}, {"output": "whats up"})memory.save_context({"input": "not much you"}, {"output": "not much"}) ``` ## Using in a chain[​](#using-in-a-chain "Direct link to Using in a chain") Let’s walk through an example, again setting `verbose=True` so we can see the prompt. ``` from langchain.chains import ConversationChainconversation_with_summary = ConversationChain( llm=llm, # We set a very low max_token_limit for the purposes of testing. memory=ConversationTokenBufferMemory(llm=OpenAI(), max_token_limit=60), verbose=True,)conversation_with_summary.predict(input="Hi, what's up?") ``` ``` > 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: Hi, what's up?AI:> Finished chain. ``` ``` " Hi there! I'm doing great, just enjoying the day. How about you?" ``` ``` conversation_with_summary.predict(input="Just working on writing some documentation!") ``` ``` > 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: Hi, what's up?AI: Hi there! I'm doing great, just enjoying the day. How about you?Human: Just working on writing some documentation!AI:> Finished chain. ``` ``` ' Sounds like a productive day! What kind of documentation are you writing?' ``` ``` conversation_with_summary.predict(input="For LangChain! Have you heard of it?") ``` ``` > 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: Hi, what's up?AI: Hi there! I'm doing great, just enjoying the day. How about you?Human: Just working on writing some documentation!AI: Sounds like a productive day! What kind of documentation are you writing?Human: For LangChain! Have you heard of it?AI:> Finished chain. ``` ``` " Yes, I have heard of LangChain! It is a decentralized language-learning platform that connects native speakers and learners in real time. Is that the documentation you're writing about?" ``` ``` # We can see here that the buffer is updatedconversation_with_summary.predict( input="Haha nope, although a lot of people confuse it for that") ``` ``` > 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: For LangChain! Have you heard of it?AI: Yes, I have heard of LangChain! It is a decentralized language-learning platform that connects native speakers and learners in real time. Is that the documentation you're writing about?Human: Haha nope, although a lot of people confuse it for thatAI:> Finished chain. ``` ``` " Oh, I see. Is there another language learning platform you're referring to?" ```

Conversation Token Buffer ConversationTokenBufferMemory keeps a buffer of recent interactions in memory, and uses token length rather than number of interactions to determine when to flush interactions. Let’s first walk through how to use the utilities. Using memory with LLM​ from langchain.memory import ConversationTokenBufferMemory from langchain_openai import OpenAI llm = OpenAI() memory = ConversationTokenBufferMemory(llm=llm, max_token_limit=10) memory.save_context({"input": "hi"}, {"output": "whats up"}) memory.save_context({"input": "not much you"}, {"output": "not much"}) memory.load_memory_variables({}) {'history': 'Human: not much you\nAI: not much'} We can also get the history as a list of messages (this is useful if you are using this with a chat model). memory = ConversationTokenBufferMemory( llm=llm, max_token_limit=10, return_messages=True ) memory.save_context({"input": "hi"}, {"output": "whats up"}) memory.save_context({"input": "not much you"}, {"output": "not much"}) Using in a chain​ Let’s walk through an example, again setting verbose=True so we can see the prompt. from langchain.chains import ConversationChain conversation_with_summary = ConversationChain( llm=llm, # We set a very low max_token_limit for the purposes of testing. memory=ConversationTokenBufferMemory(llm=OpenAI(), max_token_limit=60), verbose=True, ) conversation_with_summary.predict(input="Hi, what's up?") > 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: Hi, what's up? AI: > Finished chain. " Hi there! I'm doing great, just enjoying the day. How about you?" conversation_with_summary.predict(input="Just working on writing some documentation!") > 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: Hi, what's up? AI: Hi there! I'm doing great, just enjoying the day. How about you? Human: Just working on writing some documentation! AI: > Finished chain. ' Sounds like a productive day! What kind of documentation are you writing?' conversation_with_summary.predict(input="For LangChain! Have you heard of it?") > 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: Hi, what's up? AI: Hi there! I'm doing great, just enjoying the day. How about you? Human: Just working on writing some documentation! AI: Sounds like a productive day! What kind of documentation are you writing? Human: For LangChain! Have you heard of it? AI: > Finished chain. " Yes, I have heard of LangChain! It is a decentralized language-learning platform that connects native speakers and learners in real time. Is that the documentation you're writing about?" # We can see here that the buffer is updated conversation_with_summary.predict( input="Haha nope, although a lot of people confuse it for that" ) > 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: For LangChain! Have you heard of it? AI: Yes, I have heard of LangChain! It is a decentralized language-learning platform that connects native speakers and learners in real time. Is that the documentation you're writing about? Human: Haha nope, although a lot of people confuse it for that AI: > Finished chain. " Oh, I see. Is there another language learning platform you're referring to?"

https://python.langchain.com/docs/modules/model_io/

## Model I/O The core element of any language model application is...the model. LangChain gives you the building blocks to interface with any language model.  ## Quickstart The below quickstart will cover the basics of using LangChain's Model I/O components. It will introduce the two different types of models - LLMs and Chat Models. It will then cover how to use Prompt Templates to format the inputs to these models, and how to use Output Parsers to work with the outputs. Language models in LangChain come in two flavors: ### [ChatModels](https://python.langchain.com/docs/modules/model_io/chat/)[​](#chatmodels "Direct link to chatmodels") [Chat models](https://python.langchain.com/docs/modules/model_io/chat/) are often backed by LLMs but tuned specifically for having conversations. Crucially, their provider APIs use a different interface than pure text completion models. Instead of a single string, they take a list of chat messages as input and they return an AI message as output. See the section below for more details on what exactly a message consists of. GPT-4 and Anthropic's Claude-2 are both implemented as chat models. ### [LLMs](https://python.langchain.com/docs/modules/model_io/llms/)[​](#llms "Direct link to llms") [LLMs](https://python.langchain.com/docs/modules/model_io/llms/) in LangChain refer to pure text completion models. The APIs they wrap take a string prompt as input and output a string completion. OpenAI's GPT-3 is implemented as an LLM. These two API types have different input and output schemas. Additionally, not all models are the same. Different models have different prompting strategies that work best for them. For example, Anthropic's models work best with XML while OpenAI's work best with JSON. You should keep this in mind when designing your apps. For this getting started guide, we will use chat models and will provide a few options: using an API like Anthropic or OpenAI, or using a local open source model via Ollama. * OpenAI * Local (using Ollama) * Anthropic (chat model only) * Cohere (chat model only) First we'll need to install their partner package: ``` pip install langchain-openai ``` Accessing the API requires an API key, which you can get by creating an account and heading [here](https://platform.openai.com/account/api-keys). Once we have a key we'll want to set it as an environment variable by running: ``` export OPENAI_API_KEY="..." ``` We can then initialize the model: ``` from langchain_openai import ChatOpenAIfrom langchain_openai import OpenAIllm = OpenAI()chat_model = ChatOpenAI(model="gpt-3.5-turbo-0125") ``` If you'd prefer not to set an environment variable you can pass the key in directly via the `api_key` named parameter when initiating the OpenAI LLM class: ``` from langchain_openai import ChatOpenAIllm = ChatOpenAI(api_key="...") ``` Both `llm` and `chat_model` are objects that represent configuration for a particular model. You can initialize them with parameters like `temperature` and others, and pass them around. The main difference between them is their input and output schemas. The LLM objects take string as input and output string. The ChatModel objects take a list of messages as input and output a message. We can see the difference between an LLM and a ChatModel when we invoke it. ``` from langchain_core.messages import HumanMessagetext = "What would be a good company name for a company that makes colorful socks?"messages = [HumanMessage(content=text)]llm.invoke(text)# >> Feetful of Funchat_model.invoke(messages)# >> AIMessage(content="Socks O'Color") ``` The LLM returns a string, while the ChatModel returns a message. ## Prompt Templates[​](#prompt-templates "Direct link to Prompt Templates") Most LLM applications do not pass user input directly into an LLM. Usually they will add the user input to a larger piece of text, called a prompt template, that provides additional context on the specific task at hand. In the previous example, the text we passed to the model contained instructions to generate a company name. For our application, it would be great if the user only had to provide the description of a company/product without worrying about giving the model instructions. PromptTemplates help with exactly this! They bundle up all the logic for going from user input into a fully formatted prompt. This can start off very simple - for example, a prompt to produce the above string would just be: ``` from langchain_core.prompts import PromptTemplateprompt = PromptTemplate.from_template("What is a good name for a company that makes {product}?")prompt.format(product="colorful socks") ``` ``` What is a good name for a company that makes colorful socks? ``` There are several advantages of using these over raw string formatting. You can "partial" out variables - e.g. you can format only some of the variables at a time. You can compose them together, easily combining different templates into a single prompt. For explanations of these functionalities, see the [section on prompts](https://python.langchain.com/docs/modules/model_io/prompts/) for more detail. `PromptTemplate`s can also be used to produce a list of messages. In this case, the prompt not only contains information about the content, but also each message (its role, its position in the list, etc.). Here, what happens most often is a `ChatPromptTemplate` is a list of `ChatMessageTemplates`. Each `ChatMessageTemplate` contains instructions for how to format that `ChatMessage` - its role, and then also its content. Let's take a look at this below: ``` from langchain_core.prompts.chat import ChatPromptTemplatetemplate = "You are a helpful assistant that translates {input_language} to {output_language}."human_template = "{text}"chat_prompt = ChatPromptTemplate.from_messages([ ("system", template), ("human", human_template),])chat_prompt.format_messages(input_language="English", output_language="French", text="I love programming.") ``` ``` [ SystemMessage(content="You are a helpful assistant that translates English to French.", additional_kwargs={}), HumanMessage(content="I love programming.")] ``` ChatPromptTemplates can also be constructed in other ways - see the [section on prompts](https://python.langchain.com/docs/modules/model_io/prompts/) for more detail. ## Output parsers[​](#output-parsers "Direct link to Output parsers") `OutputParser`s convert the raw output of a language model into a format that can be used downstream. There are a few main types of `OutputParser`s, including: * Convert text from `LLM` into structured information (e.g. JSON) * Convert a `ChatMessage` into just a string * Convert the extra information returned from a call besides the message (like OpenAI function invocation) into a string. For full information on this, see the [section on output parsers](https://python.langchain.com/docs/modules/model_io/output_parsers/). In this getting started guide, we use a simple one that parses a list of comma separated values. ``` from langchain.output_parsers import CommaSeparatedListOutputParseroutput_parser = CommaSeparatedListOutputParser()output_parser.parse("hi, bye")# >> ['hi', 'bye'] ``` ## Composing with LCEL[​](#composing-with-lcel "Direct link to Composing with LCEL") We can now combine all these into one chain. This chain will take input variables, pass those to a prompt template to create a prompt, pass the prompt to a language model, and then pass the output through an (optional) output parser. This is a convenient way to bundle up a modular piece of logic. Let's see it in action! ``` template = "Generate a list of 5 {text}.\n\n{format_instructions}"chat_prompt = ChatPromptTemplate.from_template(template)chat_prompt = chat_prompt.partial(format_instructions=output_parser.get_format_instructions())chain = chat_prompt | chat_model | output_parserchain.invoke({"text": "colors"})# >> ['red', 'blue', 'green', 'yellow', 'orange'] ``` Note that we are using the `|` syntax to join these components together. This `|` syntax is powered by the LangChain Expression Language (LCEL) and relies on the universal `Runnable` interface that all of these objects implement. To learn more about LCEL, read the documentation [here](https://python.langchain.com/docs/expression_language/). ## Conclusion[​](#conclusion "Direct link to Conclusion") That's it for getting started with prompts, models, and output parsers! This just covered the surface of what there is to learn. For more information, check out: * The [prompts section](https://python.langchain.com/docs/modules/model_io/prompts/) for information on how to work with prompt templates * The [ChatModel section](https://python.langchain.com/docs/modules/model_io/chat/) for more information on the ChatModel interface * The [LLM section](https://python.langchain.com/docs/modules/model_io/llms/) for more information on the LLM interface * The [output parser section](https://python.langchain.com/docs/modules/model_io/output_parsers/) for information about the different types of output parsers.

Model I/O The core element of any language model application is...the model. LangChain gives you the building blocks to interface with any language model. Quickstart The below quickstart will cover the basics of using LangChain's Model I/O components. It will introduce the two different types of models - LLMs and Chat Models. It will then cover how to use Prompt Templates to format the inputs to these models, and how to use Output Parsers to work with the outputs. Language models in LangChain come in two flavors: ChatModels​ Chat models are often backed by LLMs but tuned specifically for having conversations. Crucially, their provider APIs use a different interface than pure text completion models. Instead of a single string, they take a list of chat messages as input and they return an AI message as output. See the section below for more details on what exactly a message consists of. GPT-4 and Anthropic's Claude-2 are both implemented as chat models. LLMs​ LLMs in LangChain refer to pure text completion models. The APIs they wrap take a string prompt as input and output a string completion. OpenAI's GPT-3 is implemented as an LLM. These two API types have different input and output schemas. Additionally, not all models are the same. Different models have different prompting strategies that work best for them. For example, Anthropic's models work best with XML while OpenAI's work best with JSON. You should keep this in mind when designing your apps. For this getting started guide, we will use chat models and will provide a few options: using an API like Anthropic or OpenAI, or using a local open source model via Ollama. OpenAI Local (using Ollama) Anthropic (chat model only) Cohere (chat model only) First we'll need to install their partner package: pip install langchain-openai Accessing the API requires an API key, which you can get by creating an account and heading here. Once we have a key we'll want to set it as an environment variable by running: export OPENAI_API_KEY="..." We can then initialize the model: from langchain_openai import ChatOpenAI from langchain_openai import OpenAI llm = OpenAI() chat_model = ChatOpenAI(model="gpt-3.5-turbo-0125") If you'd prefer not to set an environment variable you can pass the key in directly via the api_key named parameter when initiating the OpenAI LLM class: from langchain_openai import ChatOpenAI llm = ChatOpenAI(api_key="...") Both llm and chat_model are objects that represent configuration for a particular model. You can initialize them with parameters like temperature and others, and pass them around. The main difference between them is their input and output schemas. The LLM objects take string as input and output string. The ChatModel objects take a list of messages as input and output a message. We can see the difference between an LLM and a ChatModel when we invoke it. from langchain_core.messages import HumanMessage text = "What would be a good company name for a company that makes colorful socks?" messages = [HumanMessage(content=text)] llm.invoke(text) # >> Feetful of Fun chat_model.invoke(messages) # >> AIMessage(content="Socks O'Color") The LLM returns a string, while the ChatModel returns a message. Prompt Templates​ Most LLM applications do not pass user input directly into an LLM. Usually they will add the user input to a larger piece of text, called a prompt template, that provides additional context on the specific task at hand. In the previous example, the text we passed to the model contained instructions to generate a company name. For our application, it would be great if the user only had to provide the description of a company/product without worrying about giving the model instructions. PromptTemplates help with exactly this! They bundle up all the logic for going from user input into a fully formatted prompt. This can start off very simple - for example, a prompt to produce the above string would just be: from langchain_core.prompts import PromptTemplate prompt = PromptTemplate.from_template("What is a good name for a company that makes {product}?") prompt.format(product="colorful socks") What is a good name for a company that makes colorful socks? There are several advantages of using these over raw string formatting. You can "partial" out variables - e.g. you can format only some of the variables at a time. You can compose them together, easily combining different templates into a single prompt. For explanations of these functionalities, see the section on prompts for more detail. PromptTemplates can also be used to produce a list of messages. In this case, the prompt not only contains information about the content, but also each message (its role, its position in the list, etc.). Here, what happens most often is a ChatPromptTemplate is a list of ChatMessageTemplates. Each ChatMessageTemplate contains instructions for how to format that ChatMessage - its role, and then also its content. Let's take a look at this below: from langchain_core.prompts.chat import ChatPromptTemplate template = "You are a helpful assistant that translates {input_language} to {output_language}." human_template = "{text}" chat_prompt = ChatPromptTemplate.from_messages([ ("system", template), ("human", human_template), ]) chat_prompt.format_messages(input_language="English", output_language="French", text="I love programming.") [ SystemMessage(content="You are a helpful assistant that translates English to French.", additional_kwargs={}), HumanMessage(content="I love programming.") ] ChatPromptTemplates can also be constructed in other ways - see the section on prompts for more detail. Output parsers​ OutputParsers convert the raw output of a language model into a format that can be used downstream. There are a few main types of OutputParsers, including: Convert text from LLM into structured information (e.g. JSON) Convert a ChatMessage into just a string Convert the extra information returned from a call besides the message (like OpenAI function invocation) into a string. For full information on this, see the section on output parsers. In this getting started guide, we use a simple one that parses a list of comma separated values. from langchain.output_parsers import CommaSeparatedListOutputParser output_parser = CommaSeparatedListOutputParser() output_parser.parse("hi, bye") # >> ['hi', 'bye'] Composing with LCEL​ We can now combine all these into one chain. This chain will take input variables, pass those to a prompt template to create a prompt, pass the prompt to a language model, and then pass the output through an (optional) output parser. This is a convenient way to bundle up a modular piece of logic. Let's see it in action! template = "Generate a list of 5 {text}.\n\n{format_instructions}" chat_prompt = ChatPromptTemplate.from_template(template) chat_prompt = chat_prompt.partial(format_instructions=output_parser.get_format_instructions()) chain = chat_prompt | chat_model | output_parser chain.invoke({"text": "colors"}) # >> ['red', 'blue', 'green', 'yellow', 'orange'] Note that we are using the | syntax to join these components together. This | syntax is powered by the LangChain Expression Language (LCEL) and relies on the universal Runnable interface that all of these objects implement. To learn more about LCEL, read the documentation here. Conclusion​ That's it for getting started with prompts, models, and output parsers! This just covered the surface of what there is to learn. For more information, check out: The prompts section for information on how to work with prompt templates The ChatModel section for more information on the ChatModel interface The LLM section for more information on the LLM interface The output parser section for information about the different types of output parsers.

https://python.langchain.com/docs/modules/model_io/chat/

## Chat Models Chat Models are a core component of LangChain. A chat model is a language model that uses chat messages as inputs and returns chat messages as outputs (as opposed to using plain text). LangChain has integrations with many model providers (OpenAI, Cohere, Hugging Face, etc.) and exposes a standard interface to interact with all of these models. LangChain allows you to use models in sync, async, batching and streaming modes and provides other features (e.g., caching) and more. ## [Quick Start](https://python.langchain.com/docs/modules/model_io/chat/quick_start/)[​](#quick-start "Direct link to quick-start") Check out [this quick start](https://python.langchain.com/docs/modules/model_io/chat/quick_start/) to get an overview of working with ChatModels, including all the different methods they expose ## [Integrations](https://python.langchain.com/docs/integrations/chat/)[​](#integrations "Direct link to integrations") For a full list of all LLM integrations that LangChain provides, please go to the [Integrations page](https://python.langchain.com/docs/integrations/chat/) ## How-To Guides[​](#how-to-guides "Direct link to How-To Guides") We have several how-to guides for more advanced usage of LLMs. This includes: * [How to cache ChatModel responses](https://python.langchain.com/docs/modules/model_io/chat/chat_model_caching/) * [How to use ChatModels that support function calling](https://python.langchain.com/docs/modules/model_io/chat/function_calling/) * [How to stream responses from a ChatModel](https://python.langchain.com/docs/modules/model_io/chat/streaming/) * [How to track token usage in a ChatModel call](https://python.langchain.com/docs/modules/model_io/chat/token_usage_tracking/) * [How to create a custom ChatModel](https://python.langchain.com/docs/modules/model_io/chat/custom_chat_model/)

Chat Models Chat Models are a core component of LangChain. A chat model is a language model that uses chat messages as inputs and returns chat messages as outputs (as opposed to using plain text). LangChain has integrations with many model providers (OpenAI, Cohere, Hugging Face, etc.) and exposes a standard interface to interact with all of these models. LangChain allows you to use models in sync, async, batching and streaming modes and provides other features (e.g., caching) and more. Quick Start​ Check out this quick start to get an overview of working with ChatModels, including all the different methods they expose Integrations​ For a full list of all LLM integrations that LangChain provides, please go to the Integrations page How-To Guides​ We have several how-to guides for more advanced usage of LLMs. This includes: How to cache ChatModel responses How to use ChatModels that support function calling How to stream responses from a ChatModel How to track token usage in a ChatModel call How to create a custom ChatModel

https://python.langchain.com/docs/modules/memory/

## \[Beta\] Memory Most LLM applications have a conversational interface. An essential component of a conversation is being able to refer to information introduced earlier in the conversation. At bare minimum, a conversational system should be able to access some window of past messages directly. A more complex system will need to have a world model that it is constantly updating, which allows it to do things like maintain information about entities and their relationships. We call this ability to store information about past interactions "memory". LangChain provides a lot of utilities for adding memory to a system. These utilities can be used by themselves or incorporated seamlessly into a chain. Most of memory-related functionality in LangChain is marked as beta. This is for two reasons: 1. Most functionality (with some exceptions, see below) are not production ready 2. Most functionality (with some exceptions, see below) work with Legacy chains, not the newer LCEL syntax. The main exception to this is the `ChatMessageHistory` functionality. This functionality is largely production ready and does integrate with LCEL. * [LCEL Runnables](https://python.langchain.com/docs/expression_language/how_to/message_history/): For an overview of how to use `ChatMessageHistory` with LCEL runnables, see these docs * [Integrations](https://python.langchain.com/docs/integrations/memory/): For an introduction to the various `ChatMessageHistory` integrations, see these docs ## Introduction[​](#introduction "Direct link to Introduction") A memory system needs to support two basic actions: reading and writing. Recall that every chain defines some core execution logic that expects certain inputs. Some of these inputs come directly from the user, but some of these inputs can come from memory. A chain will interact with its memory system twice in a given run. 1. AFTER receiving the initial user inputs but BEFORE executing the core logic, a chain will READ from its memory system and augment the user inputs. 2. AFTER executing the core logic but BEFORE returning the answer, a chain will WRITE the inputs and outputs of the current run to memory, so that they can be referred to in future runs.  ## Building memory into a system[​](#building-memory-into-a-system "Direct link to Building memory into a system") The two core design decisions in any memory system are: * How state is stored * How state is queried ### Storing: List of chat messages[​](#storing-list-of-chat-messages "Direct link to Storing: List of chat messages") Underlying any memory is a history of all chat interactions. Even if these are not all used directly, they need to be stored in some form. One of the key parts of the LangChain memory module is a series of integrations for storing these chat messages, from in-memory lists to persistent databases. * [Chat message storage](https://python.langchain.com/docs/modules/memory/chat_messages/): How to work with Chat Messages, and the various integrations offered. ### Querying: Data structures and algorithms on top of chat messages[​](#querying-data-structures-and-algorithms-on-top-of-chat-messages "Direct link to Querying: Data structures and algorithms on top of chat messages") Keeping a list of chat messages is fairly straight-forward. What is less straight-forward are the data structures and algorithms built on top of chat messages that serve a view of those messages that is most useful. A very simple memory system might just return the most recent messages each run. A slightly more complex memory system might return a succinct summary of the past K messages. An even more sophisticated system might extract entities from stored messages and only return information about entities referenced in the current run. Each application can have different requirements for how memory is queried. The memory module should make it easy to both get started with simple memory systems and write your own custom systems if needed. * [Memory types](https://python.langchain.com/docs/modules/memory/types/): The various data structures and algorithms that make up the memory types LangChain supports ## Get started[​](#get-started "Direct link to Get started") Let's take a look at what Memory actually looks like in LangChain. Here we'll cover the basics of interacting with an arbitrary memory class. Let's take a look at how to use `ConversationBufferMemory` in chains. `ConversationBufferMemory` is an extremely simple form of memory that just keeps a list of chat messages in a buffer and passes those into the prompt template. ``` from langchain.memory import ConversationBufferMemorymemory = ConversationBufferMemory()memory.chat_memory.add_user_message("hi!")memory.chat_memory.add_ai_message("what's up?") ``` When using memory in a chain, there are a few key concepts to understand. Note that here we cover general concepts that are useful for most types of memory. Each individual memory type may very well have its own parameters and concepts that are necessary to understand. ### What variables get returned from memory[​](#what-variables-get-returned-from-memory "Direct link to What variables get returned from memory") Before going into the chain, various variables are read from memory. These have specific names which need to align with the variables the chain expects. You can see what these variables are by calling `memory.load_memory_variables({})`. Note that the empty dictionary that we pass in is just a placeholder for real variables. If the memory type you are using is dependent upon the input variables, you may need to pass some in. ``` memory.load_memory_variables({}) ``` ``` {'history': "Human: hi!\nAI: what's up?"} ``` In this case, you can see that `load_memory_variables` returns a single key, `history`. This means that your chain (and likely your prompt) should expect an input named `history`. You can usually control this variable through parameters on the memory class. For example, if you want the memory variables to be returned in the key `chat_history` you can do: ``` memory = ConversationBufferMemory(memory_key="chat_history")memory.chat_memory.add_user_message("hi!")memory.chat_memory.add_ai_message("what's up?") ``` ``` {'chat_history': "Human: hi!\nAI: what's up?"} ``` The parameter name to control these keys may vary per memory type, but it's important to understand that (1) this is controllable, and (2) how to control it. ### Whether memory is a string or a list of messages[​](#whether-memory-is-a-string-or-a-list-of-messages "Direct link to Whether memory is a string or a list of messages") One of the most common types of memory involves returning a list of chat messages. These can either be returned as a single string, all concatenated together (useful when they will be passed into LLMs) or a list of ChatMessages (useful when passed into ChatModels). By default, they are returned as a single string. In order to return as a list of messages, you can set `return_messages=True` ``` memory = ConversationBufferMemory(return_messages=True)memory.chat_memory.add_user_message("hi!")memory.chat_memory.add_ai_message("what's up?") ``` ``` {'history': [HumanMessage(content='hi!', additional_kwargs={}, example=False), AIMessage(content='what's up?', additional_kwargs={}, example=False)]} ``` ### What keys are saved to memory[​](#what-keys-are-saved-to-memory "Direct link to What keys are saved to memory") Often times chains take in or return multiple input/output keys. In these cases, how can we know which keys we want to save to the chat message history? This is generally controllable by `input_key` and `output_key` parameters on the memory types. These default to `None` - and if there is only one input/output key it is known to just use that. However, if there are multiple input/output keys then you MUST specify the name of which one to use. ### End to end example[​](#end-to-end-example "Direct link to End to end example") Finally, let's take a look at using this in a chain. We'll use an `LLMChain`, and show working with both an LLM and a ChatModel. #### Using an LLM[​](#using-an-llm "Direct link to Using an LLM") ``` from langchain_openai import OpenAIfrom langchain_core.prompts import PromptTemplatefrom langchain.chains import LLMChainfrom langchain.memory import ConversationBufferMemoryllm = OpenAI(temperature=0)# Notice that "chat_history" is present in the prompt templatetemplate = """You are a nice chatbot having a conversation with a human.Previous conversation:{chat_history}New human question: {question}Response:"""prompt = PromptTemplate.from_template(template)# Notice that we need to align the `memory_key`memory = ConversationBufferMemory(memory_key="chat_history")conversation = LLMChain( llm=llm, prompt=prompt, verbose=True, memory=memory) ``` ``` # Notice that we just pass in the `question` variables - `chat_history` gets populated by memoryconversation({"question": "hi"}) ``` #### Using a ChatModel[​](#using-a-chatmodel "Direct link to Using a ChatModel") ``` from langchain_openai import ChatOpenAIfrom langchain_core.prompts import ( ChatPromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, HumanMessagePromptTemplate,)from langchain.chains import LLMChainfrom langchain.memory import ConversationBufferMemoryllm = ChatOpenAI()prompt = ChatPromptTemplate( messages=[ SystemMessagePromptTemplate.from_template( "You are a nice chatbot having a conversation with a human." ), # The `variable_name` here is what must align with memory MessagesPlaceholder(variable_name="chat_history"), HumanMessagePromptTemplate.from_template("{question}") ])# Notice that we `return_messages=True` to fit into the MessagesPlaceholder# Notice that `"chat_history"` aligns with the MessagesPlaceholder name.memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)conversation = LLMChain( llm=llm, prompt=prompt, verbose=True, memory=memory) ``` ``` # Notice that we just pass in the `question` variables - `chat_history` gets populated by memoryconversation({"question": "hi"}) ``` ## Next steps[​](#next-steps "Direct link to Next steps") And that's it for getting started! Please see the other sections for walkthroughs of more advanced topics, like custom memory, multiple memories, and more.

[Beta] Memory Most LLM applications have a conversational interface. An essential component of a conversation is being able to refer to information introduced earlier in the conversation. At bare minimum, a conversational system should be able to access some window of past messages directly. A more complex system will need to have a world model that it is constantly updating, which allows it to do things like maintain information about entities and their relationships. We call this ability to store information about past interactions "memory". LangChain provides a lot of utilities for adding memory to a system. These utilities can be used by themselves or incorporated seamlessly into a chain. Most of memory-related functionality in LangChain is marked as beta. This is for two reasons: Most functionality (with some exceptions, see below) are not production ready Most functionality (with some exceptions, see below) work with Legacy chains, not the newer LCEL syntax. The main exception to this is the ChatMessageHistory functionality. This functionality is largely production ready and does integrate with LCEL. LCEL Runnables: For an overview of how to use ChatMessageHistory with LCEL runnables, see these docs Integrations: For an introduction to the various ChatMessageHistory integrations, see these docs Introduction​ A memory system needs to support two basic actions: reading and writing. Recall that every chain defines some core execution logic that expects certain inputs. Some of these inputs come directly from the user, but some of these inputs can come from memory. A chain will interact with its memory system twice in a given run. AFTER receiving the initial user inputs but BEFORE executing the core logic, a chain will READ from its memory system and augment the user inputs. AFTER executing the core logic but BEFORE returning the answer, a chain will WRITE the inputs and outputs of the current run to memory, so that they can be referred to in future runs. Building memory into a system​ The two core design decisions in any memory system are: How state is stored How state is queried Storing: List of chat messages​ Underlying any memory is a history of all chat interactions. Even if these are not all used directly, they need to be stored in some form. One of the key parts of the LangChain memory module is a series of integrations for storing these chat messages, from in-memory lists to persistent databases. Chat message storage: How to work with Chat Messages, and the various integrations offered. Querying: Data structures and algorithms on top of chat messages​ Keeping a list of chat messages is fairly straight-forward. What is less straight-forward are the data structures and algorithms built on top of chat messages that serve a view of those messages that is most useful. A very simple memory system might just return the most recent messages each run. A slightly more complex memory system might return a succinct summary of the past K messages. An even more sophisticated system might extract entities from stored messages and only return information about entities referenced in the current run. Each application can have different requirements for how memory is queried. The memory module should make it easy to both get started with simple memory systems and write your own custom systems if needed. Memory types: The various data structures and algorithms that make up the memory types LangChain supports Get started​ Let's take a look at what Memory actually looks like in LangChain. Here we'll cover the basics of interacting with an arbitrary memory class. Let's take a look at how to use ConversationBufferMemory in chains. ConversationBufferMemory is an extremely simple form of memory that just keeps a list of chat messages in a buffer and passes those into the prompt template. from langchain.memory import ConversationBufferMemory memory = ConversationBufferMemory() memory.chat_memory.add_user_message("hi!") memory.chat_memory.add_ai_message("what's up?") When using memory in a chain, there are a few key concepts to understand. Note that here we cover general concepts that are useful for most types of memory. Each individual memory type may very well have its own parameters and concepts that are necessary to understand. What variables get returned from memory​ Before going into the chain, various variables are read from memory. These have specific names which need to align with the variables the chain expects. You can see what these variables are by calling memory.load_memory_variables({}). Note that the empty dictionary that we pass in is just a placeholder for real variables. If the memory type you are using is dependent upon the input variables, you may need to pass some in. memory.load_memory_variables({}) {'history': "Human: hi!\nAI: what's up?"} In this case, you can see that load_memory_variables returns a single key, history. This means that your chain (and likely your prompt) should expect an input named history. You can usually control this variable through parameters on the memory class. For example, if you want the memory variables to be returned in the key chat_history you can do: memory = ConversationBufferMemory(memory_key="chat_history") memory.chat_memory.add_user_message("hi!") memory.chat_memory.add_ai_message("what's up?") {'chat_history': "Human: hi!\nAI: what's up?"} The parameter name to control these keys may vary per memory type, but it's important to understand that (1) this is controllable, and (2) how to control it. Whether memory is a string or a list of messages​ One of the most common types of memory involves returning a list of chat messages. These can either be returned as a single string, all concatenated together (useful when they will be passed into LLMs) or a list of ChatMessages (useful when passed into ChatModels). By default, they are returned as a single string. In order to return as a list of messages, you can set return_messages=True memory = ConversationBufferMemory(return_messages=True) memory.chat_memory.add_user_message("hi!") memory.chat_memory.add_ai_message("what's up?") {'history': [HumanMessage(content='hi!', additional_kwargs={}, example=False), AIMessage(content='what's up?', additional_kwargs={}, example=False)]} What keys are saved to memory​ Often times chains take in or return multiple input/output keys. In these cases, how can we know which keys we want to save to the chat message history? This is generally controllable by input_key and output_key parameters on the memory types. These default to None - and if there is only one input/output key it is known to just use that. However, if there are multiple input/output keys then you MUST specify the name of which one to use. End to end example​ Finally, let's take a look at using this in a chain. We'll use an LLMChain, and show working with both an LLM and a ChatModel. Using an LLM​ 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) # Notice that "chat_history" is present in the prompt template template = """You are a nice chatbot having a conversation with a human. Previous conversation: {chat_history} New human question: {question} Response:""" prompt = PromptTemplate.from_template(template) # Notice that we need to align the `memory_key` memory = ConversationBufferMemory(memory_key="chat_history") conversation = LLMChain( llm=llm, prompt=prompt, verbose=True, memory=memory ) # Notice that we just pass in the `question` variables - `chat_history` gets populated by memory conversation({"question": "hi"}) Using a ChatModel​ from langchain_openai import ChatOpenAI from langchain_core.prompts import ( ChatPromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, HumanMessagePromptTemplate, ) from langchain.chains import LLMChain from langchain.memory import ConversationBufferMemory llm = ChatOpenAI() prompt = ChatPromptTemplate( messages=[ SystemMessagePromptTemplate.from_template( "You are a nice chatbot having a conversation with a human." ), # The `variable_name` here is what must align with memory MessagesPlaceholder(variable_name="chat_history"), HumanMessagePromptTemplate.from_template("{question}") ] ) # Notice that we `return_messages=True` to fit into the MessagesPlaceholder # Notice that `"chat_history"` aligns with the MessagesPlaceholder name. memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True) conversation = LLMChain( llm=llm, prompt=prompt, verbose=True, memory=memory ) # Notice that we just pass in the `question` variables - `chat_history` gets populated by memory conversation({"question": "hi"}) Next steps​ And that's it for getting started! Please see the other sections for walkthroughs of more advanced topics, like custom memory, multiple memories, and more.

https://python.langchain.com/docs/modules/memory/adding_memory_chain_multiple_inputs/

Most memory objects assume a single input. In this notebook, we go over how to add memory to a chain that has multiple inputs. We will add memory to a question/answering chain. This chain takes as inputs both related documents and a user question. ``` from langchain_chroma import Chromafrom langchain_openai import OpenAIEmbeddingsfrom langchain_text_splitters import CharacterTextSplitter ``` ``` with open("../../state_of_the_union.txt") as f: state_of_the_union = f.read()text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)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))]) ``` ``` Running Chroma using direct local API.Using DuckDB in-memory for database. Data will be transient. ``` ``` query = "What did the president say about Justice Breyer"docs = docsearch.similarity_search(query) ``` ``` from langchain.chains.question_answering import load_qa_chainfrom langchain.memory import ConversationBufferMemoryfrom langchain_core.prompts import PromptTemplatefrom langchain_openai import OpenAI ``` ``` template = """You are a chatbot having a conversation with a human.Given the following extracted parts of a long document and a question, create a final answer.{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 = "What did the president say about Justice Breyer"chain({"input_documents": docs, "human_input": query}, return_only_outputs=True) ``` ``` {'output_text': ' Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service.'} ``` ``` print(chain.memory.buffer) ``` ``` Human: What did the president say about Justice BreyerAI: Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. ``` * * * #### Help us out by providing feedback on this documentation page:

Most memory objects assume a single input. In this notebook, we go over how to add memory to a chain that has multiple inputs. We will add memory to a question/answering chain. This chain takes as inputs both related documents and a user question. from langchain_chroma import Chroma from langchain_openai import OpenAIEmbeddings from langchain_text_splitters import CharacterTextSplitter with open("../../state_of_the_union.txt") as f: state_of_the_union = f.read() text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0) 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))] ) Running Chroma using direct local API. Using DuckDB in-memory for database. Data will be transient. query = "What did the president say about Justice Breyer" docs = docsearch.similarity_search(query) 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 = """You are a chatbot having a conversation with a human. Given the following extracted parts of a long document and a question, create a final answer. {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 = "What did the president say about Justice Breyer" chain({"input_documents": docs, "human_input": query}, return_only_outputs=True) {'output_text': ' Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service.'} print(chain.memory.buffer) Human: What did the president say about Justice Breyer AI: Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/modules/model_io/chat/chat_model_caching/

## Caching LangChain provides an optional caching layer for chat models. This is useful for two reasons: It can save you money by reducing the number of API calls you make to the LLM provider, if you’re often requesting the same completion multiple times. It can speed up your application by reducing the number of API calls you make to the LLM provider. * OpenAI * Anthropic * Google * Cohere * FireworksAI * MistralAI * TogetherAI ##### Install dependencies ``` pip install -qU langchain-openai ``` ##### Set environment variables ``` import getpassimport osos.environ["OPENAI_API_KEY"] = getpass.getpass() ``` ``` from langchain_openai import ChatOpenAIllm = ChatOpenAI(model="gpt-3.5-turbo-0125") ``` ``` # <!-- ruff: noqa: F821 -->from langchain.globals import set_llm_cache ``` ## In Memory Cache[​](#in-memory-cache "Direct link to In Memory Cache") ``` %%timefrom langchain.cache import InMemoryCacheset_llm_cache(InMemoryCache())# The first time, it is not yet in cache, so it should take longerllm.predict("Tell me a joke") ``` ``` CPU times: user 17.7 ms, sys: 9.35 ms, total: 27.1 msWall time: 801 ms ``` ``` "Sure, here's a classic one for you:\n\nWhy don't scientists trust atoms?\n\nBecause they make up everything!" ``` ``` %%time# The second time it is, so it goes fasterllm.predict("Tell me a joke") ``` ``` CPU times: user 1.42 ms, sys: 419 µs, total: 1.83 msWall time: 1.83 ms ``` ``` "Sure, here's a classic one for you:\n\nWhy don't scientists trust atoms?\n\nBecause they make up everything!" ``` ## SQLite Cache[​](#sqlite-cache "Direct link to SQLite Cache") ``` # We can do the same thing with a SQLite cachefrom langchain.cache import SQLiteCacheset_llm_cache(SQLiteCache(database_path=".langchain.db")) ``` ``` %%time# The first time, it is not yet in cache, so it should take longerllm.predict("Tell me a joke") ``` ``` CPU times: user 23.2 ms, sys: 17.8 ms, total: 40.9 msWall time: 592 ms ``` ``` "Sure, here's a classic one for you:\n\nWhy don't scientists trust atoms?\n\nBecause they make up everything!" ``` ``` %%time# The second time it is, so it goes fasterllm.predict("Tell me a joke") ``` ``` CPU times: user 5.61 ms, sys: 22.5 ms, total: 28.1 msWall time: 47.5 ms ``` ``` "Sure, here's a classic one for you:\n\nWhy don't scientists trust atoms?\n\nBecause they make up everything!" ``` * * * #### Help us out by providing feedback on this documentation page:

Caching LangChain provides an optional caching layer for chat models. This is useful for two reasons: It can save you money by reducing the number of API calls you make to the LLM provider, if you’re often requesting the same completion multiple times. It can speed up your application by reducing the number of API calls you make to the LLM provider. OpenAI Anthropic Google Cohere FireworksAI MistralAI TogetherAI Install dependencies pip install -qU langchain-openai Set environment variables import getpass import os os.environ["OPENAI_API_KEY"] = getpass.getpass() from langchain_openai import ChatOpenAI llm = ChatOpenAI(model="gpt-3.5-turbo-0125") # <!-- ruff: noqa: F821 --> from langchain.globals import set_llm_cache In Memory Cache​ %%time from langchain.cache import InMemoryCache set_llm_cache(InMemoryCache()) # The first time, it is not yet in cache, so it should take longer llm.predict("Tell me a joke") CPU times: user 17.7 ms, sys: 9.35 ms, total: 27.1 ms Wall time: 801 ms "Sure, here's a classic one for you:\n\nWhy don't scientists trust atoms?\n\nBecause they make up everything!" %%time # The second time it is, so it goes faster llm.predict("Tell me a joke") CPU times: user 1.42 ms, sys: 419 µs, total: 1.83 ms Wall time: 1.83 ms "Sure, here's a classic one for you:\n\nWhy don't scientists trust atoms?\n\nBecause they make up everything!" SQLite Cache​ # We can do the same thing with a SQLite cache from langchain.cache import SQLiteCache set_llm_cache(SQLiteCache(database_path=".langchain.db")) %%time # The first time, it is not yet in cache, so it should take longer llm.predict("Tell me a joke") CPU times: user 23.2 ms, sys: 17.8 ms, total: 40.9 ms Wall time: 592 ms "Sure, here's a classic one for you:\n\nWhy don't scientists trust atoms?\n\nBecause they make up everything!" %%time # The second time it is, so it goes faster llm.predict("Tell me a joke") CPU times: user 5.61 ms, sys: 22.5 ms, total: 28.1 ms Wall time: 47.5 ms "Sure, here's a classic one for you:\n\nWhy don't scientists trust atoms?\n\nBecause they make up everything!" Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/modules/model_io/chat/custom_chat_model/

## Custom Chat Model In this guide, we’ll learn how to create a custom chat model using LangChain abstractions. Wrapping your LLM with the standard `BaseChatModel` interface allow you to use your LLM in existing LangChain programs with minimal code modifications! As an bonus, your LLM will automatically become a LangChain `Runnable` and will benefit from some optimizations out of the box (e.g., batch via a threadpool), async support, the `astream_events` API, etc. ## Inputs and outputs[​](#inputs-and-outputs "Direct link to Inputs and outputs") First, we need to talk about **messages** which are the inputs and outputs of chat models. ### Messages[​](#messages "Direct link to Messages") Chat models take messages as inputs and return a message as output. LangChain has a few built-in message types: | Message Type | Description | | --- | --- | | `SystemMessage` | Used for priming AI behavior, usually passed in as the first of a sequence of input messages. | | `HumanMessage` | Represents a message from a person interacting with the chat model. | | `AIMessage` | Represents a message from the chat model. This can be either text or a request to invoke a tool. | | `FunctionMessage` / `ToolMessage` | Message for passing the results of tool invocation back to the model. | | `AIMessageChunk` / `HumanMessageChunk` / … | Chunk variant of each type of message. | note `ToolMessage` and `FunctionMessage` closely follow OpenAIs `function` and `tool` roles. This is a rapidly developing field and as more models add function calling capabilities, expect that there will be additions to this schema. ``` from langchain_core.messages import ( AIMessage, BaseMessage, FunctionMessage, HumanMessage, SystemMessage, ToolMessage,) ``` ### Streaming Variant[​](#streaming-variant "Direct link to Streaming Variant") All the chat messages have a streaming variant that contains `Chunk` in the name. ``` from langchain_core.messages import ( AIMessageChunk, FunctionMessageChunk, HumanMessageChunk, SystemMessageChunk, ToolMessageChunk,) ``` These chunks are used when streaming output from chat models, and they all define an additive property! ``` AIMessageChunk(content="Hello") + AIMessageChunk(content=" World!") ``` ``` AIMessageChunk(content='Hello World!') ``` ## Base Chat Model[​](#base-chat-model "Direct link to Base Chat Model") Let’s implement a chat model that echoes back the first `n` characetrs of the last message in the prompt! To do so, we will inherit from `BaseChatModel` and we’ll need to implement the following: | Method/Property | Description | Required/Optional | | --- | --- | --- | | `_generate` | Use to generate a chat result from a prompt | Required | | `_llm_type` (property) | Used to uniquely identify the type of the model. Used for logging. | Required | | `_identifying_params` (property) | Represent model parameterization for tracing purposes. | Optional | | `_stream` | Use to implement streaming. | Optional | | `_agenerate` | Use to implement a native async method. | Optional | | `_astream` | Use to implement async version of `_stream`. | Optional | tip The `_astream` implementation uses `run_in_executor` to launch the sync `_stream` in a separate thread if `_stream` is implemented, otherwise it fallsback to use `_agenerate`. You can use this trick if you want to reuse the `_stream` implementation, but if you’re able to implement code that’s natively async that’s a better solution since that code will run with less overhead. ### Implementation[​](#implementation "Direct link to Implementation") ``` from typing import Any, AsyncIterator, Dict, Iterator, List, Optionalfrom langchain_core.callbacks import ( AsyncCallbackManagerForLLMRun, CallbackManagerForLLMRun,)from langchain_core.language_models import BaseChatModel, SimpleChatModelfrom langchain_core.messages import AIMessageChunk, BaseMessage, HumanMessagefrom langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResultfrom langchain_core.runnables import run_in_executorclass CustomChatModelAdvanced(BaseChatModel): """A custom chat model that echoes the first `n` characters of the input. When contributing an implementation to LangChain, carefully document the model including the initialization parameters, include an example of how to initialize the model and include any relevant links to the underlying models documentation or API. Example: .. code-block:: python model = CustomChatModel(n=2) result = model.invoke([HumanMessage(content="hello")]) result = model.batch([[HumanMessage(content="hello")], [HumanMessage(content="world")]]) """ model_name: str """The name of the model""" n: int """The number of characters from the last message of the prompt to be echoed.""" def _generate( self, messages: List[BaseMessage], stop: Optional[List[str]] = None, run_manager: Optional[CallbackManagerForLLMRun] = None, **kwargs: Any, ) -> ChatResult: """Override the _generate method to implement the chat model logic. This can be a call to an API, a call to a local model, or any other implementation that generates a response to the input prompt. Args: messages: the prompt composed of a list of messages. stop: a list of strings on which the model should stop generating. If generation stops due to a stop token, the stop token itself SHOULD BE INCLUDED as part of the output. This is not enforced across models right now, but it's a good practice to follow since it makes it much easier to parse the output of the model downstream and understand why generation stopped. run_manager: A run manager with callbacks for the LLM. """ # Replace this with actual logic to generate a response from a list # of messages. last_message = messages[-1] tokens = last_message.content[: self.n] message = AIMessage( content=tokens, additional_kwargs={}, # Used to add additional payload (e.g., function calling request) response_metadata={ # Use for response metadata "time_in_seconds": 3, }, ) ## generation = ChatGeneration(message=message) return ChatResult(generations=[generation]) def _stream( self, messages: List[BaseMessage], stop: Optional[List[str]] = None, run_manager: Optional[CallbackManagerForLLMRun] = None, **kwargs: Any, ) -> Iterator[ChatGenerationChunk]: """Stream the output of the model. This method should be implemented if the model can generate output in a streaming fashion. If the model does not support streaming, do not implement it. In that case streaming requests will be automatically handled by the _generate method. Args: messages: the prompt composed of a list of messages. stop: a list of strings on which the model should stop generating. If generation stops due to a stop token, the stop token itself SHOULD BE INCLUDED as part of the output. This is not enforced across models right now, but it's a good practice to follow since it makes it much easier to parse the output of the model downstream and understand why generation stopped. run_manager: A run manager with callbacks for the LLM. """ last_message = messages[-1] tokens = last_message.content[: self.n] for token in tokens: chunk = ChatGenerationChunk(message=AIMessageChunk(content=token)) if run_manager: # This is optional in newer versions of LangChain # The on_llm_new_token will be called automatically run_manager.on_llm_new_token(token, chunk=chunk) yield chunk # Let's add some other information (e.g., response metadata) chunk = ChatGenerationChunk( message=AIMessageChunk(content="", response_metadata={"time_in_sec": 3}) ) if run_manager: # This is optional in newer versions of LangChain # The on_llm_new_token will be called automatically run_manager.on_llm_new_token(token, chunk=chunk) yield chunk @property def _llm_type(self) -> str: """Get the type of language model used by this chat model.""" return "echoing-chat-model-advanced" @property def _identifying_params(self) -> Dict[str, Any]: """Return a dictionary of identifying parameters. This information is used by the LangChain callback system, which is used for tracing purposes make it possible to monitor LLMs. """ return { # The model name allows users to specify custom token counting # rules in LLM monitoring applications (e.g., in LangSmith users # can provide per token pricing for their model and monitor # costs for the given LLM.) "model_name": self.model_name, } ``` ### Let’s test it 🧪[​](#lets-test-it "Direct link to Let’s test it 🧪") The chat model will implement the standard `Runnable` interface of LangChain which many of the LangChain abstractions support! ``` model = CustomChatModelAdvanced(n=3, model_name="my_custom_model") ``` ``` model.invoke( [ HumanMessage(content="hello!"), AIMessage(content="Hi there human!"), HumanMessage(content="Meow!"), ]) ``` ``` AIMessage(content='Meo', response_metadata={'time_in_seconds': 3}, id='run-ddb42bd6-4fdd-4bd2-8be5-e11b67d3ac29-0') ``` ``` AIMessage(content='hel', response_metadata={'time_in_seconds': 3}, id='run-4d3cc912-44aa-454b-977b-ca02be06c12e-0') ``` ``` model.batch(["hello", "goodbye"]) ``` ``` [AIMessage(content='hel', response_metadata={'time_in_seconds': 3}, id='run-9620e228-1912-4582-8aa1-176813afec49-0'), AIMessage(content='goo', response_metadata={'time_in_seconds': 3}, id='run-1ce8cdf8-6f75-448e-82f7-1bb4a121df93-0')] ``` ``` for chunk in model.stream("cat"): print(chunk.content, end="|") ``` Please see the implementation of `_astream` in the model! If you do not implement it, then no output will stream.! ``` async for chunk in model.astream("cat"): print(chunk.content, end="|") ``` Let’s try to use the astream events API which will also help double check that all the callbacks were implemented! ``` async for event in model.astream_events("cat", version="v1"): print(event) ``` ``` {'event': 'on_chat_model_start', 'run_id': '125a2a16-b9cd-40de-aa08-8aa9180b07d0', 'name': 'CustomChatModelAdvanced', 'tags': [], 'metadata': {}, 'data': {'input': 'cat'}}{'event': 'on_chat_model_stream', 'run_id': '125a2a16-b9cd-40de-aa08-8aa9180b07d0', 'tags': [], 'metadata': {}, 'name': 'CustomChatModelAdvanced', 'data': {'chunk': AIMessageChunk(content='c', id='run-125a2a16-b9cd-40de-aa08-8aa9180b07d0')}}{'event': 'on_chat_model_stream', 'run_id': '125a2a16-b9cd-40de-aa08-8aa9180b07d0', 'tags': [], 'metadata': {}, 'name': 'CustomChatModelAdvanced', 'data': {'chunk': AIMessageChunk(content='a', id='run-125a2a16-b9cd-40de-aa08-8aa9180b07d0')}}{'event': 'on_chat_model_stream', 'run_id': '125a2a16-b9cd-40de-aa08-8aa9180b07d0', 'tags': [], 'metadata': {}, 'name': 'CustomChatModelAdvanced', 'data': {'chunk': AIMessageChunk(content='t', id='run-125a2a16-b9cd-40de-aa08-8aa9180b07d0')}}{'event': 'on_chat_model_stream', 'run_id': '125a2a16-b9cd-40de-aa08-8aa9180b07d0', 'tags': [], 'metadata': {}, 'name': 'CustomChatModelAdvanced', 'data': {'chunk': AIMessageChunk(content='', response_metadata={'time_in_sec': 3}, id='run-125a2a16-b9cd-40de-aa08-8aa9180b07d0')}}{'event': 'on_chat_model_end', 'name': 'CustomChatModelAdvanced', 'run_id': '125a2a16-b9cd-40de-aa08-8aa9180b07d0', 'tags': [], 'metadata': {}, 'data': {'output': AIMessageChunk(content='cat', response_metadata={'time_in_sec': 3}, id='run-125a2a16-b9cd-40de-aa08-8aa9180b07d0')}} ``` ``` /home/eugene/src/langchain/libs/core/langchain_core/_api/beta_decorator.py:87: LangChainBetaWarning: This API is in beta and may change in the future. warn_beta( ``` ## Contributing[​](#contributing "Direct link to Contributing") We appreciate all chat model integration contributions. Here’s a checklist to help make sure your contribution gets added to LangChain: Documentation: * The model contains doc-strings for all initialization arguments, as these will be surfaced in the [APIReference](https://api.python.langchain.com/en/stable/langchain_api_reference.html). * The class doc-string for the model contains a link to the model API if the model is powered by a service. Tests: * ☐ Add unit or integration tests to the overridden methods. Verify that `invoke`, `ainvoke`, `batch`, `stream` work if you’ve over-ridden the corresponding code. Streaming (if you’re implementing it): * ☐ Implement the \_stream method to get streaming working Stop Token Behavior: * ☐ Stop token should be respected * ☐ Stop token should be INCLUDED as part of the response Secret API Keys: * ☐ If your model connects to an API it will likely accept API keys as part of its initialization. Use Pydantic’s `SecretStr` type for secrets, so they don’t get accidentally printed out when folks print the model. Identifying Params: * ☐ Include a `model_name` in identifying params Optimizations: Consider providing native async support to reduce the overhead from the model! * ☐ Provided a native async of `_agenerate` (used by `ainvoke`) * ☐ Provided a native async of `_astream` (used by `astream`)

Custom Chat Model In this guide, we’ll learn how to create a custom chat model using LangChain abstractions. Wrapping your LLM with the standard BaseChatModel interface allow you to use your LLM in existing LangChain programs with minimal code modifications! As an bonus, your LLM will automatically become a LangChain Runnable and will benefit from some optimizations out of the box (e.g., batch via a threadpool), async support, the astream_events API, etc. Inputs and outputs​ First, we need to talk about messages which are the inputs and outputs of chat models. Messages​ Chat models take messages as inputs and return a message as output. LangChain has a few built-in message types: Message TypeDescription SystemMessage Used for priming AI behavior, usually passed in as the first of a sequence of input messages. HumanMessage Represents a message from a person interacting with the chat model. AIMessage Represents a message from the chat model. This can be either text or a request to invoke a tool. FunctionMessage / ToolMessage Message for passing the results of tool invocation back to the model. AIMessageChunk / HumanMessageChunk / … Chunk variant of each type of message. note ToolMessage and FunctionMessage closely follow OpenAIs function and tool roles. This is a rapidly developing field and as more models add function calling capabilities, expect that there will be additions to this schema. from langchain_core.messages import ( AIMessage, BaseMessage, FunctionMessage, HumanMessage, SystemMessage, ToolMessage, ) Streaming Variant​ All the chat messages have a streaming variant that contains Chunk in the name. from langchain_core.messages import ( AIMessageChunk, FunctionMessageChunk, HumanMessageChunk, SystemMessageChunk, ToolMessageChunk, ) These chunks are used when streaming output from chat models, and they all define an additive property! AIMessageChunk(content="Hello") + AIMessageChunk(content=" World!") AIMessageChunk(content='Hello World!') Base Chat Model​ Let’s implement a chat model that echoes back the first n characetrs of the last message in the prompt! To do so, we will inherit from BaseChatModel and we’ll need to implement the following: Method/PropertyDescriptionRequired/Optional _generate Use to generate a chat result from a prompt Required _llm_type (property) Used to uniquely identify the type of the model. Used for logging. Required _identifying_params (property) Represent model parameterization for tracing purposes. Optional _stream Use to implement streaming. Optional _agenerate Use to implement a native async method. Optional _astream Use to implement async version of _stream. Optional tip The _astream implementation uses run_in_executor to launch the sync _stream in a separate thread if _stream is implemented, otherwise it fallsback to use _agenerate. You can use this trick if you want to reuse the _stream implementation, but if you’re able to implement code that’s natively async that’s a better solution since that code will run with less overhead. Implementation​ from typing import Any, AsyncIterator, Dict, Iterator, List, Optional from langchain_core.callbacks import ( AsyncCallbackManagerForLLMRun, CallbackManagerForLLMRun, ) from langchain_core.language_models import BaseChatModel, SimpleChatModel from langchain_core.messages import AIMessageChunk, BaseMessage, HumanMessage from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult from langchain_core.runnables import run_in_executor class CustomChatModelAdvanced(BaseChatModel): """A custom chat model that echoes the first `n` characters of the input. When contributing an implementation to LangChain, carefully document the model including the initialization parameters, include an example of how to initialize the model and include any relevant links to the underlying models documentation or API. Example: .. code-block:: python model = CustomChatModel(n=2) result = model.invoke([HumanMessage(content="hello")]) result = model.batch([[HumanMessage(content="hello")], [HumanMessage(content="world")]]) """ model_name: str """The name of the model""" n: int """The number of characters from the last message of the prompt to be echoed.""" def _generate( self, messages: List[BaseMessage], stop: Optional[List[str]] = None, run_manager: Optional[CallbackManagerForLLMRun] = None, **kwargs: Any, ) -> ChatResult: """Override the _generate method to implement the chat model logic. This can be a call to an API, a call to a local model, or any other implementation that generates a response to the input prompt. Args: messages: the prompt composed of a list of messages. stop: a list of strings on which the model should stop generating. If generation stops due to a stop token, the stop token itself SHOULD BE INCLUDED as part of the output. This is not enforced across models right now, but it's a good practice to follow since it makes it much easier to parse the output of the model downstream and understand why generation stopped. run_manager: A run manager with callbacks for the LLM. """ # Replace this with actual logic to generate a response from a list # of messages. last_message = messages[-1] tokens = last_message.content[: self.n] message = AIMessage( content=tokens, additional_kwargs={}, # Used to add additional payload (e.g., function calling request) response_metadata={ # Use for response metadata "time_in_seconds": 3, }, ) ## generation = ChatGeneration(message=message) return ChatResult(generations=[generation]) def _stream( self, messages: List[BaseMessage], stop: Optional[List[str]] = None, run_manager: Optional[CallbackManagerForLLMRun] = None, **kwargs: Any, ) -> Iterator[ChatGenerationChunk]: """Stream the output of the model. This method should be implemented if the model can generate output in a streaming fashion. If the model does not support streaming, do not implement it. In that case streaming requests will be automatically handled by the _generate method. Args: messages: the prompt composed of a list of messages. stop: a list of strings on which the model should stop generating. If generation stops due to a stop token, the stop token itself SHOULD BE INCLUDED as part of the output. This is not enforced across models right now, but it's a good practice to follow since it makes it much easier to parse the output of the model downstream and understand why generation stopped. run_manager: A run manager with callbacks for the LLM. """ last_message = messages[-1] tokens = last_message.content[: self.n] for token in tokens: chunk = ChatGenerationChunk(message=AIMessageChunk(content=token)) if run_manager: # This is optional in newer versions of LangChain # The on_llm_new_token will be called automatically run_manager.on_llm_new_token(token, chunk=chunk) yield chunk # Let's add some other information (e.g., response metadata) chunk = ChatGenerationChunk( message=AIMessageChunk(content="", response_metadata={"time_in_sec": 3}) ) if run_manager: # This is optional in newer versions of LangChain # The on_llm_new_token will be called automatically run_manager.on_llm_new_token(token, chunk=chunk) yield chunk @property def _llm_type(self) -> str: """Get the type of language model used by this chat model.""" return "echoing-chat-model-advanced" @property def _identifying_params(self) -> Dict[str, Any]: """Return a dictionary of identifying parameters. This information is used by the LangChain callback system, which is used for tracing purposes make it possible to monitor LLMs. """ return { # The model name allows users to specify custom token counting # rules in LLM monitoring applications (e.g., in LangSmith users # can provide per token pricing for their model and monitor # costs for the given LLM.) "model_name": self.model_name, } Let’s test it 🧪​ The chat model will implement the standard Runnable interface of LangChain which many of the LangChain abstractions support! model = CustomChatModelAdvanced(n=3, model_name="my_custom_model") model.invoke( [ HumanMessage(content="hello!"), AIMessage(content="Hi there human!"), HumanMessage(content="Meow!"), ] ) AIMessage(content='Meo', response_metadata={'time_in_seconds': 3}, id='run-ddb42bd6-4fdd-4bd2-8be5-e11b67d3ac29-0') AIMessage(content='hel', response_metadata={'time_in_seconds': 3}, id='run-4d3cc912-44aa-454b-977b-ca02be06c12e-0') model.batch(["hello", "goodbye"]) [AIMessage(content='hel', response_metadata={'time_in_seconds': 3}, id='run-9620e228-1912-4582-8aa1-176813afec49-0'), AIMessage(content='goo', response_metadata={'time_in_seconds': 3}, id='run-1ce8cdf8-6f75-448e-82f7-1bb4a121df93-0')] for chunk in model.stream("cat"): print(chunk.content, end="|") Please see the implementation of _astream in the model! If you do not implement it, then no output will stream.! async for chunk in model.astream("cat"): print(chunk.content, end="|") Let’s try to use the astream events API which will also help double check that all the callbacks were implemented! async for event in model.astream_events("cat", version="v1"): print(event) {'event': 'on_chat_model_start', 'run_id': '125a2a16-b9cd-40de-aa08-8aa9180b07d0', 'name': 'CustomChatModelAdvanced', 'tags': [], 'metadata': {}, 'data': {'input': 'cat'}} {'event': 'on_chat_model_stream', 'run_id': '125a2a16-b9cd-40de-aa08-8aa9180b07d0', 'tags': [], 'metadata': {}, 'name': 'CustomChatModelAdvanced', 'data': {'chunk': AIMessageChunk(content='c', id='run-125a2a16-b9cd-40de-aa08-8aa9180b07d0')}} {'event': 'on_chat_model_stream', 'run_id': '125a2a16-b9cd-40de-aa08-8aa9180b07d0', 'tags': [], 'metadata': {}, 'name': 'CustomChatModelAdvanced', 'data': {'chunk': AIMessageChunk(content='a', id='run-125a2a16-b9cd-40de-aa08-8aa9180b07d0')}} {'event': 'on_chat_model_stream', 'run_id': '125a2a16-b9cd-40de-aa08-8aa9180b07d0', 'tags': [], 'metadata': {}, 'name': 'CustomChatModelAdvanced', 'data': {'chunk': AIMessageChunk(content='t', id='run-125a2a16-b9cd-40de-aa08-8aa9180b07d0')}} {'event': 'on_chat_model_stream', 'run_id': '125a2a16-b9cd-40de-aa08-8aa9180b07d0', 'tags': [], 'metadata': {}, 'name': 'CustomChatModelAdvanced', 'data': {'chunk': AIMessageChunk(content='', response_metadata={'time_in_sec': 3}, id='run-125a2a16-b9cd-40de-aa08-8aa9180b07d0')}} {'event': 'on_chat_model_end', 'name': 'CustomChatModelAdvanced', 'run_id': '125a2a16-b9cd-40de-aa08-8aa9180b07d0', 'tags': [], 'metadata': {}, 'data': {'output': AIMessageChunk(content='cat', response_metadata={'time_in_sec': 3}, id='run-125a2a16-b9cd-40de-aa08-8aa9180b07d0')}} /home/eugene/src/langchain/libs/core/langchain_core/_api/beta_decorator.py:87: LangChainBetaWarning: This API is in beta and may change in the future. warn_beta( Contributing​ We appreciate all chat model integration contributions. Here’s a checklist to help make sure your contribution gets added to LangChain: Documentation: The model contains doc-strings for all initialization arguments, as these will be surfaced in the APIReference. The class doc-string for the model contains a link to the model API if the model is powered by a service. Tests: ☐ Add unit or integration tests to the overridden methods. Verify that invoke, ainvoke, batch, stream work if you’ve over-ridden the corresponding code. Streaming (if you’re implementing it): ☐ Implement the _stream method to get streaming working Stop Token Behavior: ☐ Stop token should be respected ☐ Stop token should be INCLUDED as part of the response Secret API Keys: ☐ If your model connects to an API it will likely accept API keys as part of its initialization. Use Pydantic’s SecretStr type for secrets, so they don’t get accidentally printed out when folks print the model. Identifying Params: ☐ Include a model_name in identifying params Optimizations: Consider providing native async support to reduce the overhead from the model! ☐ Provided a native async of _agenerate (used by ainvoke) ☐ Provided a native async of _astream (used by astream)

https://python.langchain.com/docs/modules/model_io/chat/function_calling/

## Tool calling info We use the term tool calling interchangeably with function calling. Although function calling is sometimes meant to refer to invocations of a single function, we treat all models as though they can return multiple tool or function calls in each message. Tool calling allows a model to respond to a given prompt by generating output that matches a user-defined schema. While the name implies that the model is performing some action, this is actually not the case! The model is coming up with the arguments to a tool, and actually running the tool (or not) is up to the user - for example, if you want to [extract output matching some schema](https://python.langchain.com/docs/use_cases/extraction/) from unstructured text, you could give the model an “extraction” tool that takes parameters matching the desired schema, then treat the generated output as your final result. A tool call includes a name, arguments dict, and an optional identifier. The arguments dict is structured `{argument_name: argument_value}`. Many LLM providers, including [Anthropic](https://www.anthropic.com/), [Cohere](https://cohere.com/), [Google](https://cloud.google.com/vertex-ai), [Mistral](https://mistral.ai/), [OpenAI](https://openai.com/), and others, support variants of a tool calling feature. These features typically allow requests to the LLM to include available tools and their schemas, and for responses to include calls to these tools. For instance, given a search engine tool, an LLM might handle a query by first issuing a call to the search engine. The system calling the LLM can receive the tool call, execute it, and return the output to the LLM to inform its response. LangChain includes a suite of [built-in tools](https://python.langchain.com/docs/integrations/tools/) and supports several methods for defining your own [custom tools](https://python.langchain.com/docs/modules/tools/custom_tools/). Tool-calling is extremely useful for building [tool-using chains and agents](https://python.langchain.com/docs/use_cases/tool_use/), and for getting structured outputs from models more generally. Providers adopt different conventions for formatting tool schemas and tool calls. For instance, Anthropic returns tool calls as parsed structures within a larger content block: ``` [ { "text": "<thinking>\nI should use a tool.\n</thinking>", "type": "text" }, { "id": "id_value", "input": {"arg_name": "arg_value"}, "name": "tool_name", "type": "tool_use" }] ``` whereas OpenAI separates tool calls into a distinct parameter, with arguments as JSON strings: ``` { "tool_calls": [ { "id": "id_value", "function": { "arguments": '{"arg_name": "arg_value"}', "name": "tool_name" }, "type": "function" } ]} ``` LangChain implements standard interfaces for defining tools, passing them to LLMs, and representing tool calls. Chat models supporting tool calling features implement a `.bind_tools` method, which receives a list of LangChain [tool objects](https://api.python.langchain.com/en/latest/tools/langchain_core.tools.BaseTool.html#langchain_core.tools.BaseTool) and binds them to the chat model in its expected format. Subsequent invocations of the chat model will include tool schemas in its calls to the LLM. For example, we can define the schema for custom tools using the `@tool` decorator on Python functions: ``` from langchain_core.tools import tool@tooldef add(a: int, b: int) -> int: """Adds a and b.""" return a + b@tooldef multiply(a: int, b: int) -> int: """Multiplies a and b.""" return a * btools = [add, multiply] ``` Or below, we define the schema using Pydantic: ``` from langchain_core.pydantic_v1 import BaseModel, Field# Note that the docstrings here are crucial, as they will be passed along# to the model along with the class name.class Add(BaseModel): """Add two integers together.""" a: int = Field(..., description="First integer") b: int = Field(..., description="Second integer")class Multiply(BaseModel): """Multiply two integers together.""" a: int = Field(..., description="First integer") b: int = Field(..., description="Second integer")tools = [Add, Multiply] ``` We can bind them to chat models as follows: * OpenAI * Anthropic * Google * Cohere * FireworksAI * MistralAI * TogetherAI ##### Install dependencies ``` pip install -qU langchain-openai ``` ##### Set environment variables ``` import getpassimport osos.environ["OPENAI_API_KEY"] = getpass.getpass() ``` ``` from langchain_openai import ChatOpenAIllm = ChatOpenAI(model="gpt-3.5-turbo-0125") ``` We can use the `bind_tools()` method to handle converting `Multiply` to a “tool” and binding it to the model (i.e., passing it in each time the model is invoked). ``` llm_with_tools = llm.bind_tools(tools) ``` If tool calls are included in a LLM response, they are attached to the corresponding [message](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.ai.AIMessage.html#langchain_core.messages.ai.AIMessage) or [message chunk](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.ai.AIMessageChunk.html#langchain_core.messages.ai.AIMessageChunk) as a list of [tool call](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.tool.ToolCall.html#langchain_core.messages.tool.ToolCall) objects in the `.tool_calls` attribute. A `ToolCall` is a typed dict that includes a tool name, dict of argument values, and (optionally) an identifier. Messages with no tool calls default to an empty list for this attribute. Example: ``` query = "What is 3 * 12? Also, what is 11 + 49?"llm_with_tools.invoke(query).tool_calls ``` ``` [{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_1Tdp5wUXbYQzpkBoagGXqUTo'}, {'name': 'Add', 'args': {'a': 11, 'b': 49}, 'id': 'call_k9v09vYioS3X0Qg35zESuUKI'}] ``` The `.tool_calls` attribute should contain valid tool calls. Note that on occasion, model providers may output malformed tool calls (e.g., arguments that are not valid JSON). When parsing fails in these cases, instances of [InvalidToolCall](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.tool.InvalidToolCall.html#langchain_core.messages.tool.InvalidToolCall) are populated in the `.invalid_tool_calls` attribute. An `InvalidToolCall` can have a name, string arguments, identifier, and error message. If desired, [output parsers](https://python.langchain.com/docs/modules/model_io/output_parsers/) can further process the output. For example, we can convert back to the original Pydantic class: ``` from langchain_core.output_parsers.openai_tools import PydanticToolsParserchain = llm_with_tools | PydanticToolsParser(tools=[Multiply, Add])chain.invoke(query) ``` ``` [Multiply(a=3, b=12), Add(a=11, b=49)] ``` ### Streaming[​](#streaming "Direct link to Streaming") When tools are called in a streaming context, [message chunks](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.ai.AIMessageChunk.html#langchain_core.messages.ai.AIMessageChunk) will be populated with [tool call chunk](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.tool.ToolCallChunk.html#langchain_core.messages.tool.ToolCallChunk) objects in a list via the `.tool_call_chunks` attribute. A `ToolCallChunk` includes optional string fields for the tool `name`, `args`, and `id`, and includes an optional integer field `index` that can be used to join chunks together. Fields are optional because portions of a tool call may be streamed across different chunks (e.g., a chunk that includes a substring of the arguments may have null values for the tool name and id). Because message chunks inherit from their parent message class, an [AIMessageChunk](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.ai.AIMessageChunk.html#langchain_core.messages.ai.AIMessageChunk) with tool call chunks will also include `.tool_calls` and `.invalid_tool_calls` fields. These fields are parsed best-effort from the message’s tool call chunks. Note that not all providers currently support streaming for tool calls. Example: ``` async for chunk in llm_with_tools.astream(query): print(chunk.tool_call_chunks) ``` ``` [][{'name': 'Multiply', 'args': '', 'id': 'call_d39MsxKM5cmeGJOoYKdGBgzc', 'index': 0}][{'name': None, 'args': '{"a"', 'id': None, 'index': 0}][{'name': None, 'args': ': 3, ', 'id': None, 'index': 0}][{'name': None, 'args': '"b": 1', 'id': None, 'index': 0}][{'name': None, 'args': '2}', 'id': None, 'index': 0}][{'name': 'Add', 'args': '', 'id': 'call_QJpdxD9AehKbdXzMHxgDMMhs', 'index': 1}][{'name': None, 'args': '{"a"', 'id': None, 'index': 1}][{'name': None, 'args': ': 11,', 'id': None, 'index': 1}][{'name': None, 'args': ' "b": ', 'id': None, 'index': 1}][{'name': None, 'args': '49}', 'id': None, 'index': 1}][] ``` Note that adding message chunks will merge their corresponding tool call chunks. This is the principle by which LangChain’s various [tool output parsers](https://python.langchain.com/docs/modules/model_io/output_parsers/types/openai_tools/) support streaming. For example, below we accumulate tool call chunks: ``` first = Trueasync for chunk in llm_with_tools.astream(query): if first: gathered = chunk first = False else: gathered = gathered + chunk print(gathered.tool_call_chunks) ``` ``` [][{'name': 'Multiply', 'args': '', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}][{'name': 'Multiply', 'args': '{"a"', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}][{'name': 'Multiply', 'args': '{"a": 3, ', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}][{'name': 'Multiply', 'args': '{"a": 3, "b": 1', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}][{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}][{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}, {'name': 'Add', 'args': '', 'id': 'call_tYHYdEV2YBvzDcSCiFCExNvw', 'index': 1}][{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}, {'name': 'Add', 'args': '{"a"', 'id': 'call_tYHYdEV2YBvzDcSCiFCExNvw', 'index': 1}][{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}, {'name': 'Add', 'args': '{"a": 11,', 'id': 'call_tYHYdEV2YBvzDcSCiFCExNvw', 'index': 1}][{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}, {'name': 'Add', 'args': '{"a": 11, "b": ', 'id': 'call_tYHYdEV2YBvzDcSCiFCExNvw', 'index': 1}][{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}, {'name': 'Add', 'args': '{"a": 11, "b": 49}', 'id': 'call_tYHYdEV2YBvzDcSCiFCExNvw', 'index': 1}][{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}, {'name': 'Add', 'args': '{"a": 11, "b": 49}', 'id': 'call_tYHYdEV2YBvzDcSCiFCExNvw', 'index': 1}] ``` ``` print(type(gathered.tool_call_chunks[0]["args"])) ``` And below we accumulate tool calls to demonstrate partial parsing: ``` first = Trueasync for chunk in llm_with_tools.astream(query): if first: gathered = chunk first = False else: gathered = gathered + chunk print(gathered.tool_calls) ``` ``` [][][{'name': 'Multiply', 'args': {}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}][{'name': 'Multiply', 'args': {'a': 3}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}][{'name': 'Multiply', 'args': {'a': 3, 'b': 1}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}][{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}][{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}][{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}, {'name': 'Add', 'args': {}, 'id': 'call_UjSHJKROSAw2BDc8cp9cSv4i'}][{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}, {'name': 'Add', 'args': {'a': 11}, 'id': 'call_UjSHJKROSAw2BDc8cp9cSv4i'}][{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}, {'name': 'Add', 'args': {'a': 11}, 'id': 'call_UjSHJKROSAw2BDc8cp9cSv4i'}][{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}, {'name': 'Add', 'args': {'a': 11, 'b': 49}, 'id': 'call_UjSHJKROSAw2BDc8cp9cSv4i'}][{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}, {'name': 'Add', 'args': {'a': 11, 'b': 49}, 'id': 'call_UjSHJKROSAw2BDc8cp9cSv4i'}] ``` ``` print(type(gathered.tool_calls[0]["args"])) ``` If we’re using the model-generated tool invocations to actually call tools and want to pass the tool results back to the model, we can do so using `ToolMessage`s. ``` from langchain_core.messages import HumanMessage, ToolMessagemessages = [HumanMessage(query)]ai_msg = llm_with_tools.invoke(messages)messages.append(ai_msg)for tool_call in ai_msg.tool_calls: selected_tool = {"add": add, "multiply": multiply}[tool_call["name"].lower()] tool_output = selected_tool.invoke(tool_call["args"]) messages.append(ToolMessage(tool_output, tool_call_id=tool_call["id"]))messages ``` ``` [HumanMessage(content='What is 3 * 12? Also, what is 11 + 49?'), AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_K5DsWEmgt6D08EI9AFu9NaL1', 'function': {'arguments': '{"a": 3, "b": 12}', 'name': 'Multiply'}, 'type': 'function'}, {'id': 'call_qywVrsplg0ZMv7LHYYMjyG81', 'function': {'arguments': '{"a": 11, "b": 49}', 'name': 'Add'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 50, 'prompt_tokens': 105, 'total_tokens': 155}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-1a0b8cdd-9221-4d94-b2ed-5701f67ce9fe-0', tool_calls=[{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_K5DsWEmgt6D08EI9AFu9NaL1'}, {'name': 'Add', 'args': {'a': 11, 'b': 49}, 'id': 'call_qywVrsplg0ZMv7LHYYMjyG81'}]), ToolMessage(content='36', tool_call_id='call_K5DsWEmgt6D08EI9AFu9NaL1'), ToolMessage(content='60', tool_call_id='call_qywVrsplg0ZMv7LHYYMjyG81')] ``` ``` llm_with_tools.invoke(messages) ``` ``` AIMessage(content='3 * 12 is 36 and 11 + 49 is 60.', response_metadata={'token_usage': {'completion_tokens': 18, 'prompt_tokens': 171, 'total_tokens': 189}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-a6c8093c-b16a-4c92-8308-7c9ac998118c-0') ``` ## Few-shot prompting[​](#few-shot-prompting "Direct link to Few-shot prompting") For more complex tool use it’s very useful to add few-shot examples to the prompt. We can do this by adding `AIMessage`s with `ToolCall`s and corresponding `ToolMessage`s to our prompt. For example, even with some special instructions our model can get tripped up by order of operations: ``` llm_with_tools.invoke( "Whats 119 times 8 minus 20. Don't do any math yourself, only use tools for math. Respect order of operations").tool_calls ``` ``` [{'name': 'Multiply', 'args': {'a': 119, 'b': 8}, 'id': 'call_Dl3FXRVkQCFW4sUNYOe4rFr7'}, {'name': 'Add', 'args': {'a': 952, 'b': -20}, 'id': 'call_n03l4hmka7VZTCiP387Wud2C'}] ``` The model shouldn’t be trying to add anything yet, since it technically can’t know the results of 119 \* 8 yet. By adding a prompt with some examples we can correct this behavior: ``` from langchain_core.messages import AIMessagefrom langchain_core.prompts import ChatPromptTemplatefrom langchain_core.runnables import RunnablePassthroughexamples = [ HumanMessage( "What's the product of 317253 and 128472 plus four", name="example_user" ), AIMessage( "", name="example_assistant", tool_calls=[ {"name": "Multiply", "args": {"x": 317253, "y": 128472}, "id": "1"} ], ), ToolMessage("16505054784", tool_call_id="1"), AIMessage( "", name="example_assistant", tool_calls=[{"name": "Add", "args": {"x": 16505054784, "y": 4}, "id": "2"}], ), ToolMessage("16505054788", tool_call_id="2"), AIMessage( "The product of 317253 and 128472 plus four is 16505054788", name="example_assistant", ),]system = """You are bad at math but are an expert at using a calculator. Use past tool usage as an example of how to correctly use the tools."""few_shot_prompt = ChatPromptTemplate.from_messages( [ ("system", system), *examples, ("human", "{query}"), ])chain = {"query": RunnablePassthrough()} | few_shot_prompt | llm_with_toolschain.invoke("Whats 119 times 8 minus 20").tool_calls ``` ``` [{'name': 'Multiply', 'args': {'a': 119, 'b': 8}, 'id': 'call_MoSgwzIhPxhclfygkYaKIsGZ'}] ``` Seems like we get the correct output this time. Here’s what the [LangSmith trace](https://smith.langchain.com/public/f70550a1-585f-4c9d-a643-13148ab1616f/r) looks like. ## Next steps[​](#next-steps "Direct link to Next steps") * **Output parsing**: See [OpenAI Tools output parsers](https://python.langchain.com/docs/modules/model_io/output_parsers/types/openai_tools/) and [OpenAI Functions output parsers](https://python.langchain.com/docs/modules/model_io/output_parsers/types/openai_functions/) to learn about extracting the function calling API responses into various formats. * **Structured output chains**: [Some models have constructors](https://python.langchain.com/docs/modules/model_io/chat/structured_output/) that handle creating a structured output chain for you. * **Tool use**: See how to construct chains and agents that call the invoked tools in [these guides](https://python.langchain.com/docs/use_cases/tool_use/).

Tool calling info We use the term tool calling interchangeably with function calling. Although function calling is sometimes meant to refer to invocations of a single function, we treat all models as though they can return multiple tool or function calls in each message. Tool calling allows a model to respond to a given prompt by generating output that matches a user-defined schema. While the name implies that the model is performing some action, this is actually not the case! The model is coming up with the arguments to a tool, and actually running the tool (or not) is up to the user - for example, if you want to extract output matching some schema from unstructured text, you could give the model an “extraction” tool that takes parameters matching the desired schema, then treat the generated output as your final result. A tool call includes a name, arguments dict, and an optional identifier. The arguments dict is structured {argument_name: argument_value}. Many LLM providers, including Anthropic, Cohere, Google, Mistral, OpenAI, and others, support variants of a tool calling feature. These features typically allow requests to the LLM to include available tools and their schemas, and for responses to include calls to these tools. For instance, given a search engine tool, an LLM might handle a query by first issuing a call to the search engine. The system calling the LLM can receive the tool call, execute it, and return the output to the LLM to inform its response. LangChain includes a suite of built-in tools and supports several methods for defining your own custom tools. Tool-calling is extremely useful for building tool-using chains and agents, and for getting structured outputs from models more generally. Providers adopt different conventions for formatting tool schemas and tool calls. For instance, Anthropic returns tool calls as parsed structures within a larger content block: [ { "text": "<thinking>\nI should use a tool.\n</thinking>", "type": "text" }, { "id": "id_value", "input": {"arg_name": "arg_value"}, "name": "tool_name", "type": "tool_use" } ] whereas OpenAI separates tool calls into a distinct parameter, with arguments as JSON strings: { "tool_calls": [ { "id": "id_value", "function": { "arguments": '{"arg_name": "arg_value"}', "name": "tool_name" }, "type": "function" } ] } LangChain implements standard interfaces for defining tools, passing them to LLMs, and representing tool calls. Chat models supporting tool calling features implement a .bind_tools method, which receives a list of LangChain tool objects and binds them to the chat model in its expected format. Subsequent invocations of the chat model will include tool schemas in its calls to the LLM. For example, we can define the schema for custom tools using the @tool decorator on Python functions: from langchain_core.tools import tool @tool def add(a: int, b: int) -> int: """Adds a and b.""" return a + b @tool def multiply(a: int, b: int) -> int: """Multiplies a and b.""" return a * b tools = [add, multiply] Or below, we define the schema using Pydantic: from langchain_core.pydantic_v1 import BaseModel, Field # Note that the docstrings here are crucial, as they will be passed along # to the model along with the class name. class Add(BaseModel): """Add two integers together.""" a: int = Field(..., description="First integer") b: int = Field(..., description="Second integer") class Multiply(BaseModel): """Multiply two integers together.""" a: int = Field(..., description="First integer") b: int = Field(..., description="Second integer") tools = [Add, Multiply] We can bind them to chat models as follows: OpenAI Anthropic Google Cohere FireworksAI MistralAI TogetherAI Install dependencies pip install -qU langchain-openai Set environment variables import getpass import os os.environ["OPENAI_API_KEY"] = getpass.getpass() from langchain_openai import ChatOpenAI llm = ChatOpenAI(model="gpt-3.5-turbo-0125") We can use the bind_tools() method to handle converting Multiply to a “tool” and binding it to the model (i.e., passing it in each time the model is invoked). llm_with_tools = llm.bind_tools(tools) If tool calls are included in a LLM response, they are attached to the corresponding message or message chunk as a list of tool call objects in the .tool_calls attribute. A ToolCall is a typed dict that includes a tool name, dict of argument values, and (optionally) an identifier. Messages with no tool calls default to an empty list for this attribute. Example: query = "What is 3 * 12? Also, what is 11 + 49?" llm_with_tools.invoke(query).tool_calls [{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_1Tdp5wUXbYQzpkBoagGXqUTo'}, {'name': 'Add', 'args': {'a': 11, 'b': 49}, 'id': 'call_k9v09vYioS3X0Qg35zESuUKI'}] The .tool_calls attribute should contain valid tool calls. Note that on occasion, model providers may output malformed tool calls (e.g., arguments that are not valid JSON). When parsing fails in these cases, instances of InvalidToolCall are populated in the .invalid_tool_calls attribute. An InvalidToolCall can have a name, string arguments, identifier, and error message. If desired, output parsers can further process the output. For example, we can convert back to the original Pydantic class: from langchain_core.output_parsers.openai_tools import PydanticToolsParser chain = llm_with_tools | PydanticToolsParser(tools=[Multiply, Add]) chain.invoke(query) [Multiply(a=3, b=12), Add(a=11, b=49)] Streaming​ When tools are called in a streaming context, message chunks will be populated with tool call chunk objects in a list via the .tool_call_chunks attribute. A ToolCallChunk includes optional string fields for the tool name, args, and id, and includes an optional integer field index that can be used to join chunks together. Fields are optional because portions of a tool call may be streamed across different chunks (e.g., a chunk that includes a substring of the arguments may have null values for the tool name and id). Because message chunks inherit from their parent message class, an AIMessageChunk with tool call chunks will also include .tool_calls and .invalid_tool_calls fields. These fields are parsed best-effort from the message’s tool call chunks. Note that not all providers currently support streaming for tool calls. Example: async for chunk in llm_with_tools.astream(query): print(chunk.tool_call_chunks) [] [{'name': 'Multiply', 'args': '', 'id': 'call_d39MsxKM5cmeGJOoYKdGBgzc', 'index': 0}] [{'name': None, 'args': '{"a"', 'id': None, 'index': 0}] [{'name': None, 'args': ': 3, ', 'id': None, 'index': 0}] [{'name': None, 'args': '"b": 1', 'id': None, 'index': 0}] [{'name': None, 'args': '2}', 'id': None, 'index': 0}] [{'name': 'Add', 'args': '', 'id': 'call_QJpdxD9AehKbdXzMHxgDMMhs', 'index': 1}] [{'name': None, 'args': '{"a"', 'id': None, 'index': 1}] [{'name': None, 'args': ': 11,', 'id': None, 'index': 1}] [{'name': None, 'args': ' "b": ', 'id': None, 'index': 1}] [{'name': None, 'args': '49}', 'id': None, 'index': 1}] [] Note that adding message chunks will merge their corresponding tool call chunks. This is the principle by which LangChain’s various tool output parsers support streaming. For example, below we accumulate tool call chunks: first = True async for chunk in llm_with_tools.astream(query): if first: gathered = chunk first = False else: gathered = gathered + chunk print(gathered.tool_call_chunks) [] [{'name': 'Multiply', 'args': '', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}] [{'name': 'Multiply', 'args': '{"a"', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}] [{'name': 'Multiply', 'args': '{"a": 3, ', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}] [{'name': 'Multiply', 'args': '{"a": 3, "b": 1', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}] [{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}] [{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}, {'name': 'Add', 'args': '', 'id': 'call_tYHYdEV2YBvzDcSCiFCExNvw', 'index': 1}] [{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}, {'name': 'Add', 'args': '{"a"', 'id': 'call_tYHYdEV2YBvzDcSCiFCExNvw', 'index': 1}] [{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}, {'name': 'Add', 'args': '{"a": 11,', 'id': 'call_tYHYdEV2YBvzDcSCiFCExNvw', 'index': 1}] [{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}, {'name': 'Add', 'args': '{"a": 11, "b": ', 'id': 'call_tYHYdEV2YBvzDcSCiFCExNvw', 'index': 1}] [{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}, {'name': 'Add', 'args': '{"a": 11, "b": 49}', 'id': 'call_tYHYdEV2YBvzDcSCiFCExNvw', 'index': 1}] [{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}, {'name': 'Add', 'args': '{"a": 11, "b": 49}', 'id': 'call_tYHYdEV2YBvzDcSCiFCExNvw', 'index': 1}] print(type(gathered.tool_call_chunks[0]["args"])) And below we accumulate tool calls to demonstrate partial parsing: first = True async for chunk in llm_with_tools.astream(query): if first: gathered = chunk first = False else: gathered = gathered + chunk print(gathered.tool_calls) [] [] [{'name': 'Multiply', 'args': {}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}] [{'name': 'Multiply', 'args': {'a': 3}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}] [{'name': 'Multiply', 'args': {'a': 3, 'b': 1}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}] [{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}] [{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}] [{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}, {'name': 'Add', 'args': {}, 'id': 'call_UjSHJKROSAw2BDc8cp9cSv4i'}] [{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}, {'name': 'Add', 'args': {'a': 11}, 'id': 'call_UjSHJKROSAw2BDc8cp9cSv4i'}] [{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}, {'name': 'Add', 'args': {'a': 11}, 'id': 'call_UjSHJKROSAw2BDc8cp9cSv4i'}] [{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}, {'name': 'Add', 'args': {'a': 11, 'b': 49}, 'id': 'call_UjSHJKROSAw2BDc8cp9cSv4i'}] [{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}, {'name': 'Add', 'args': {'a': 11, 'b': 49}, 'id': 'call_UjSHJKROSAw2BDc8cp9cSv4i'}] print(type(gathered.tool_calls[0]["args"])) If we’re using the model-generated tool invocations to actually call tools and want to pass the tool results back to the model, we can do so using ToolMessages. from langchain_core.messages import HumanMessage, ToolMessage messages = [HumanMessage(query)] ai_msg = llm_with_tools.invoke(messages) messages.append(ai_msg) for tool_call in ai_msg.tool_calls: selected_tool = {"add": add, "multiply": multiply}[tool_call["name"].lower()] tool_output = selected_tool.invoke(tool_call["args"]) messages.append(ToolMessage(tool_output, tool_call_id=tool_call["id"])) messages [HumanMessage(content='What is 3 * 12? Also, what is 11 + 49?'), AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_K5DsWEmgt6D08EI9AFu9NaL1', 'function': {'arguments': '{"a": 3, "b": 12}', 'name': 'Multiply'}, 'type': 'function'}, {'id': 'call_qywVrsplg0ZMv7LHYYMjyG81', 'function': {'arguments': '{"a": 11, "b": 49}', 'name': 'Add'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 50, 'prompt_tokens': 105, 'total_tokens': 155}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-1a0b8cdd-9221-4d94-b2ed-5701f67ce9fe-0', tool_calls=[{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_K5DsWEmgt6D08EI9AFu9NaL1'}, {'name': 'Add', 'args': {'a': 11, 'b': 49}, 'id': 'call_qywVrsplg0ZMv7LHYYMjyG81'}]), ToolMessage(content='36', tool_call_id='call_K5DsWEmgt6D08EI9AFu9NaL1'), ToolMessage(content='60', tool_call_id='call_qywVrsplg0ZMv7LHYYMjyG81')] llm_with_tools.invoke(messages) AIMessage(content='3 * 12 is 36 and 11 + 49 is 60.', response_metadata={'token_usage': {'completion_tokens': 18, 'prompt_tokens': 171, 'total_tokens': 189}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-a6c8093c-b16a-4c92-8308-7c9ac998118c-0') Few-shot prompting​ For more complex tool use it’s very useful to add few-shot examples to the prompt. We can do this by adding AIMessages with ToolCalls and corresponding ToolMessages to our prompt. For example, even with some special instructions our model can get tripped up by order of operations: llm_with_tools.invoke( "Whats 119 times 8 minus 20. Don't do any math yourself, only use tools for math. Respect order of operations" ).tool_calls [{'name': 'Multiply', 'args': {'a': 119, 'b': 8}, 'id': 'call_Dl3FXRVkQCFW4sUNYOe4rFr7'}, {'name': 'Add', 'args': {'a': 952, 'b': -20}, 'id': 'call_n03l4hmka7VZTCiP387Wud2C'}] The model shouldn’t be trying to add anything yet, since it technically can’t know the results of 119 * 8 yet. By adding a prompt with some examples we can correct this behavior: from langchain_core.messages import AIMessage from langchain_core.prompts import ChatPromptTemplate from langchain_core.runnables import RunnablePassthrough examples = [ HumanMessage( "What's the product of 317253 and 128472 plus four", name="example_user" ), AIMessage( "", name="example_assistant", tool_calls=[ {"name": "Multiply", "args": {"x": 317253, "y": 128472}, "id": "1"} ], ), ToolMessage("16505054784", tool_call_id="1"), AIMessage( "", name="example_assistant", tool_calls=[{"name": "Add", "args": {"x": 16505054784, "y": 4}, "id": "2"}], ), ToolMessage("16505054788", tool_call_id="2"), AIMessage( "The product of 317253 and 128472 plus four is 16505054788", name="example_assistant", ), ] system = """You are bad at math but are an expert at using a calculator. Use past tool usage as an example of how to correctly use the tools.""" few_shot_prompt = ChatPromptTemplate.from_messages( [ ("system", system), *examples, ("human", "{query}"), ] ) chain = {"query": RunnablePassthrough()} | few_shot_prompt | llm_with_tools chain.invoke("Whats 119 times 8 minus 20").tool_calls [{'name': 'Multiply', 'args': {'a': 119, 'b': 8}, 'id': 'call_MoSgwzIhPxhclfygkYaKIsGZ'}] Seems like we get the correct output this time. Here’s what the LangSmith trace looks like. Next steps​ Output parsing: See OpenAI Tools output parsers and OpenAI Functions output parsers to learn about extracting the function calling API responses into various formats. Structured output chains: Some models have constructors that handle creating a structured output chain for you. Tool use: See how to construct chains and agents that call the invoked tools in these guides.

https://python.langchain.com/docs/modules/model_io/chat/logprobs/

Certain chat models can be configured to return token-level log probabilities. This guide walks through how to get logprobs for a number of models. For the OpenAI API to return log probabilities we need to configure the `logprobs=True` param The logprobs are included on each output Message as part of the `response_metadata`: ``` [{'token': 'As', 'bytes': [65, 115], 'logprob': -1.5358024, 'top_logprobs': []}, {'token': ' an', 'bytes': [32, 97, 110], 'logprob': -0.028062303, 'top_logprobs': []}, {'token': ' AI', 'bytes': [32, 65, 73], 'logprob': -0.009415812, 'top_logprobs': []}, {'token': ',', 'bytes': [44], 'logprob': -0.07371779, 'top_logprobs': []}, {'token': ' I', 'bytes': [32, 73], 'logprob': -4.298773e-05, 'top_logprobs': []}] ``` ``` [][{'token': 'As', 'bytes': [65, 115], 'logprob': -1.7523563, 'top_logprobs': []}][{'token': 'As', 'bytes': [65, 115], 'logprob': -1.7523563, 'top_logprobs': []}, {'token': ' an', 'bytes': [32, 97, 110], 'logprob': -0.019908238, 'top_logprobs': []}][{'token': 'As', 'bytes': [65, 115], 'logprob': -1.7523563, 'top_logprobs': []}, {'token': ' an', 'bytes': [32, 97, 110], 'logprob': -0.019908238, 'top_logprobs': []}, {'token': ' AI', 'bytes': [32, 65, 73], 'logprob': -0.0093033705, 'top_logprobs': []}][{'token': 'As', 'bytes': [65, 115], 'logprob': -1.7523563, 'top_logprobs': []}, {'token': ' an', 'bytes': [32, 97, 110], 'logprob': -0.019908238, 'top_logprobs': []}, {'token': ' AI', 'bytes': [32, 65, 73], 'logprob': -0.0093033705, 'top_logprobs': []}, {'token': ',', 'bytes': [44], 'logprob': -0.08852102, 'top_logprobs': []}] ```

Certain chat models can be configured to return token-level log probabilities. This guide walks through how to get logprobs for a number of models. For the OpenAI API to return log probabilities we need to configure the logprobs=True param The logprobs are included on each output Message as part of the response_metadata: [{'token': 'As', 'bytes': [65, 115], 'logprob': -1.5358024, 'top_logprobs': []}, {'token': ' an', 'bytes': [32, 97, 110], 'logprob': -0.028062303, 'top_logprobs': []}, {'token': ' AI', 'bytes': [32, 65, 73], 'logprob': -0.009415812, 'top_logprobs': []}, {'token': ',', 'bytes': [44], 'logprob': -0.07371779, 'top_logprobs': []}, {'token': ' I', 'bytes': [32, 73], 'logprob': -4.298773e-05, 'top_logprobs': []}] [] [{'token': 'As', 'bytes': [65, 115], 'logprob': -1.7523563, 'top_logprobs': []}] [{'token': 'As', 'bytes': [65, 115], 'logprob': -1.7523563, 'top_logprobs': []}, {'token': ' an', 'bytes': [32, 97, 110], 'logprob': -0.019908238, 'top_logprobs': []}] [{'token': 'As', 'bytes': [65, 115], 'logprob': -1.7523563, 'top_logprobs': []}, {'token': ' an', 'bytes': [32, 97, 110], 'logprob': -0.019908238, 'top_logprobs': []}, {'token': ' AI', 'bytes': [32, 65, 73], 'logprob': -0.0093033705, 'top_logprobs': []}] [{'token': 'As', 'bytes': [65, 115], 'logprob': -1.7523563, 'top_logprobs': []}, {'token': ' an', 'bytes': [32, 97, 110], 'logprob': -0.019908238, 'top_logprobs': []}, {'token': ' AI', 'bytes': [32, 65, 73], 'logprob': -0.0093033705, 'top_logprobs': []}, {'token': ',', 'bytes': [44], 'logprob': -0.08852102, 'top_logprobs': []}]

https://python.langchain.com/docs/modules/model_io/chat/response_metadata/

## Response metadata Many model providers include some metadata in their chat generation responses. This metadata can be accessed via the `AIMessage.response_metadata: Dict` attribute. Depending on the model provider and model configuration, this can contain information like [token counts](https://python.langchain.com/docs/modules/model_io/chat/token_usage_tracking/), [logprobs](https://python.langchain.com/docs/modules/model_io/chat/logprobs/), and more. Here’s what the response metadata looks like for a few different providers: ## OpenAI[​](#openai "Direct link to OpenAI") ``` from langchain_openai import ChatOpenAIllm = ChatOpenAI(model="gpt-4-turbo")msg = llm.invoke([("human", "What's the oldest known example of cuneiform")])msg.response_metadata ``` ``` {'token_usage': {'completion_tokens': 164, 'prompt_tokens': 17, 'total_tokens': 181}, 'model_name': 'gpt-4-turbo', 'system_fingerprint': 'fp_76f018034d', 'finish_reason': 'stop', 'logprobs': None} ``` ## Anthropic[​](#anthropic "Direct link to Anthropic") ``` from langchain_anthropic import ChatAnthropicllm = ChatAnthropic(model="claude-3-sonnet-20240229")msg = llm.invoke([("human", "What's the oldest known example of cuneiform")])msg.response_metadata ``` ``` {'id': 'msg_01CzQyD7BX8nkhDNfT1QqvEp', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 17, 'output_tokens': 296}} ``` ## Google VertexAI[​](#google-vertexai "Direct link to Google VertexAI") ``` from langchain_google_vertexai import ChatVertexAIllm = ChatVertexAI(model="gemini-pro")msg = llm.invoke([("human", "What's the oldest known example of cuneiform")])msg.response_metadata ``` ``` {'is_blocked': False, 'safety_ratings': [{'category': 'HARM_CATEGORY_HATE_SPEECH', 'probability_label': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT', 'probability_label': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HARASSMENT', 'probability_label': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT', 'probability_label': 'NEGLIGIBLE', 'blocked': False}], 'citation_metadata': None, 'usage_metadata': {'prompt_token_count': 10, 'candidates_token_count': 30, 'total_token_count': 40}} ``` ## Bedrock (Anthropic)[​](#bedrock-anthropic "Direct link to Bedrock (Anthropic)") ``` from langchain_aws import ChatBedrockllm = ChatBedrock(model_id="anthropic.claude-v2")msg = llm.invoke([("human", "What's the oldest known example of cuneiform")])msg.response_metadata ``` ``` {'model_id': 'anthropic.claude-v2', 'usage': {'prompt_tokens': 19, 'completion_tokens': 371, 'total_tokens': 390}} ``` ## MistralAI[​](#mistralai "Direct link to MistralAI") ``` from langchain_mistralai import ChatMistralAIllm = ChatMistralAI()msg = llm.invoke([("human", "What's the oldest known example of cuneiform")])msg.response_metadata ``` ``` {'token_usage': {'prompt_tokens': 19, 'total_tokens': 141, 'completion_tokens': 122}, 'model': 'mistral-small', 'finish_reason': 'stop'} ``` ## Groq[​](#groq "Direct link to Groq") ``` from langchain_groq import ChatGroqllm = ChatGroq()msg = llm.invoke([("human", "What's the oldest known example of cuneiform")])msg.response_metadata ``` ``` {'token_usage': {'completion_time': 0.243, 'completion_tokens': 132, 'prompt_time': 0.022, 'prompt_tokens': 22, 'queue_time': None, 'total_time': 0.265, 'total_tokens': 154}, 'model_name': 'mixtral-8x7b-32768', 'system_fingerprint': 'fp_7b44c65f25', 'finish_reason': 'stop', 'logprobs': None} ``` ## TogetherAI[​](#togetherai "Direct link to TogetherAI") ``` import osfrom langchain_openai import ChatOpenAIllm = ChatOpenAI( base_url="https://api.together.xyz/v1", api_key=os.environ["TOGETHER_API_KEY"], model="mistralai/Mixtral-8x7B-Instruct-v0.1",)msg = llm.invoke([("human", "What's the oldest known example of cuneiform")])msg.response_metadata ``` ``` {'token_usage': {'completion_tokens': 208, 'prompt_tokens': 20, 'total_tokens': 228}, 'model_name': 'mistralai/Mixtral-8x7B-Instruct-v0.1', 'system_fingerprint': None, 'finish_reason': 'eos', 'logprobs': None} ``` ## FireworksAI[​](#fireworksai "Direct link to FireworksAI") ``` from langchain_fireworks import ChatFireworksllm = ChatFireworks(model="accounts/fireworks/models/mixtral-8x7b-instruct")msg = llm.invoke([("human", "What's the oldest known example of cuneiform")])msg.response_metadata ``` ``` {'token_usage': {'prompt_tokens': 19, 'total_tokens': 219, 'completion_tokens': 200}, 'model_name': 'accounts/fireworks/models/mixtral-8x7b-instruct', 'system_fingerprint': '', 'finish_reason': 'length', 'logprobs': None} ```

Response metadata Many model providers include some metadata in their chat generation responses. This metadata can be accessed via the AIMessage.response_metadata: Dict attribute. Depending on the model provider and model configuration, this can contain information like token counts, logprobs, and more. Here’s what the response metadata looks like for a few different providers: OpenAI​ from langchain_openai import ChatOpenAI llm = ChatOpenAI(model="gpt-4-turbo") msg = llm.invoke([("human", "What's the oldest known example of cuneiform")]) msg.response_metadata {'token_usage': {'completion_tokens': 164, 'prompt_tokens': 17, 'total_tokens': 181}, 'model_name': 'gpt-4-turbo', 'system_fingerprint': 'fp_76f018034d', 'finish_reason': 'stop', 'logprobs': None} Anthropic​ from langchain_anthropic import ChatAnthropic llm = ChatAnthropic(model="claude-3-sonnet-20240229") msg = llm.invoke([("human", "What's the oldest known example of cuneiform")]) msg.response_metadata {'id': 'msg_01CzQyD7BX8nkhDNfT1QqvEp', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 17, 'output_tokens': 296}} Google VertexAI​ from langchain_google_vertexai import ChatVertexAI llm = ChatVertexAI(model="gemini-pro") msg = llm.invoke([("human", "What's the oldest known example of cuneiform")]) msg.response_metadata {'is_blocked': False, 'safety_ratings': [{'category': 'HARM_CATEGORY_HATE_SPEECH', 'probability_label': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT', 'probability_label': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HARASSMENT', 'probability_label': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT', 'probability_label': 'NEGLIGIBLE', 'blocked': False}], 'citation_metadata': None, 'usage_metadata': {'prompt_token_count': 10, 'candidates_token_count': 30, 'total_token_count': 40}} Bedrock (Anthropic)​ from langchain_aws import ChatBedrock llm = ChatBedrock(model_id="anthropic.claude-v2") msg = llm.invoke([("human", "What's the oldest known example of cuneiform")]) msg.response_metadata {'model_id': 'anthropic.claude-v2', 'usage': {'prompt_tokens': 19, 'completion_tokens': 371, 'total_tokens': 390}} MistralAI​ from langchain_mistralai import ChatMistralAI llm = ChatMistralAI() msg = llm.invoke([("human", "What's the oldest known example of cuneiform")]) msg.response_metadata {'token_usage': {'prompt_tokens': 19, 'total_tokens': 141, 'completion_tokens': 122}, 'model': 'mistral-small', 'finish_reason': 'stop'} Groq​ from langchain_groq import ChatGroq llm = ChatGroq() msg = llm.invoke([("human", "What's the oldest known example of cuneiform")]) msg.response_metadata {'token_usage': {'completion_time': 0.243, 'completion_tokens': 132, 'prompt_time': 0.022, 'prompt_tokens': 22, 'queue_time': None, 'total_time': 0.265, 'total_tokens': 154}, 'model_name': 'mixtral-8x7b-32768', 'system_fingerprint': 'fp_7b44c65f25', 'finish_reason': 'stop', 'logprobs': None} TogetherAI​ import os from langchain_openai import ChatOpenAI llm = ChatOpenAI( base_url="https://api.together.xyz/v1", api_key=os.environ["TOGETHER_API_KEY"], model="mistralai/Mixtral-8x7B-Instruct-v0.1", ) msg = llm.invoke([("human", "What's the oldest known example of cuneiform")]) msg.response_metadata {'token_usage': {'completion_tokens': 208, 'prompt_tokens': 20, 'total_tokens': 228}, 'model_name': 'mistralai/Mixtral-8x7B-Instruct-v0.1', 'system_fingerprint': None, 'finish_reason': 'eos', 'logprobs': None} FireworksAI​ from langchain_fireworks import ChatFireworks llm = ChatFireworks(model="accounts/fireworks/models/mixtral-8x7b-instruct") msg = llm.invoke([("human", "What's the oldest known example of cuneiform")]) msg.response_metadata {'token_usage': {'prompt_tokens': 19, 'total_tokens': 219, 'completion_tokens': 200}, 'model_name': 'accounts/fireworks/models/mixtral-8x7b-instruct', 'system_fingerprint': '', 'finish_reason': 'length', 'logprobs': None}

https://python.langchain.com/docs/modules/model_io/chat/message_types/

## Message types ChatModels take a list of messages as input and return a message. There are a few different types of messages. All messages have a `role` and a `content` property. The `role` describes WHO is saying the message. LangChain has different message classes for different roles. The `content` property describes the content of the message. This can be a few different things: * A string (most models deal this type of content) * A List of dictionaries (this is used for multi-modal input, where the dictionary contains information about that input type and that input location) In addition, messages have an `additional_kwargs` property. This is where additional information about messages can be passed. This is largely used for input parameters that are _provider specific_ and not general. The best known example of this is `function_call` from OpenAI. ### HumanMessage[​](#humanmessage "Direct link to HumanMessage") This represents a message from the user. Generally consists only of content. ### AIMessage[​](#aimessage "Direct link to AIMessage") This represents a message from the model. This may have `additional_kwargs` in it - for example `tool_calls` if using OpenAI tool calling. ### SystemMessage[​](#systemmessage "Direct link to SystemMessage") This represents a system message, which tells the model how to behave. This generally only consists of content. Not every model supports this. ### FunctionMessage[​](#functionmessage "Direct link to FunctionMessage") This represents the result of a function call. In addition to `role` and `content`, this message has a `name` parameter which conveys the name of the function that was called to produce this result. ### ToolMessage[​](#toolmessage "Direct link to ToolMessage") This represents the result of a tool call. This is distinct from a FunctionMessage in order to match OpenAI's `function` and `tool` message types. In addition to `role` and `content`, this message has a `tool_call_id` parameter which conveys the id of the call to the tool that was called to produce this result.

Message types ChatModels take a list of messages as input and return a message. There are a few different types of messages. All messages have a role and a content property. The role describes WHO is saying the message. LangChain has different message classes for different roles. The content property describes the content of the message. This can be a few different things: A string (most models deal this type of content) A List of dictionaries (this is used for multi-modal input, where the dictionary contains information about that input type and that input location) In addition, messages have an additional_kwargs property. This is where additional information about messages can be passed. This is largely used for input parameters that are provider specific and not general. The best known example of this is function_call from OpenAI. HumanMessage​ This represents a message from the user. Generally consists only of content. AIMessage​ This represents a message from the model. This may have additional_kwargs in it - for example tool_calls if using OpenAI tool calling. SystemMessage​ This represents a system message, which tells the model how to behave. This generally only consists of content. Not every model supports this. FunctionMessage​ This represents the result of a function call. In addition to role and content, this message has a name parameter which conveys the name of the function that was called to produce this result. ToolMessage​ This represents the result of a tool call. This is distinct from a FunctionMessage in order to match OpenAI's function and tool message types. In addition to role and content, this message has a tool_call_id parameter which conveys the id of the call to the tool that was called to produce this result.

https://python.langchain.com/docs/modules/model_io/chat/streaming/

All ChatModels implement the Runnable interface, which comes with default implementations of all methods, ie. ainvoke, batch, abatch, stream, astream. This gives all ChatModels basic support for streaming. Streaming support defaults to returning an Iterator (or AsyncIterator in the case of async streaming) of a single value, the final result returned by the underlying ChatModel provider. This obviously doesn’t give you token-by-token streaming, which requires native support from the ChatModel provider, but ensures your code that expects an iterator of tokens can work for any of our ChatModel integrations. ``` Here's a song I just improvised about goldfish on the moon:Floating in space, looking for a place To call their home, all aloneSwimming through stars, these goldfish from MarsLeft their fishbowl behind, a new life to findOn the moon, where the craters loomSearching for food, maybe some lunar foodOut of their depth, close to deathHow they wish, for just one small fishTo join them up here, their future unclearOn the moon, where the Earth loomsDreaming of home, filled with foamTheir bodies adapt, continuing to last On the moon, where they learn to swoonOver cheese that astronauts teaseAs they stare back at Earth, the planet of birthThese goldfish out of water, swim on and onLunar pioneers, conquering their fearsOn the moon, where they happily swoon ```

All ChatModels implement the Runnable interface, which comes with default implementations of all methods, ie. ainvoke, batch, abatch, stream, astream. This gives all ChatModels basic support for streaming. Streaming support defaults to returning an Iterator (or AsyncIterator in the case of async streaming) of a single value, the final result returned by the underlying ChatModel provider. This obviously doesn’t give you token-by-token streaming, which requires native support from the ChatModel provider, but ensures your code that expects an iterator of tokens can work for any of our ChatModel integrations. Here's a song I just improvised about goldfish on the moon: Floating in space, looking for a place To call their home, all alone Swimming through stars, these goldfish from Mars Left their fishbowl behind, a new life to find On the moon, where the craters loom Searching for food, maybe some lunar food Out of their depth, close to death How they wish, for just one small fish To join them up here, their future unclear On the moon, where the Earth looms Dreaming of home, filled with foam Their bodies adapt, continuing to last On the moon, where they learn to swoon Over cheese that astronauts tease As they stare back at Earth, the planet of birth These goldfish out of water, swim on and on Lunar pioneers, conquering their fears On the moon, where they happily swoon

https://python.langchain.com/docs/modules/model_io/chat/quick_start/

Chat models are a variation on language models. While chat models use language models under the hood, the interface they use is a bit different. Rather than using a “text in, text out” API, they use an interface where “chat messages” are the inputs and outputs. If you’d prefer not to set an environment variable you can pass the key in directly via the api key arg named parameter when initiating the chat model class: The chat model interface is based around messages rather than raw text. The types of messages currently supported in LangChain are `AIMessage`, `HumanMessage`, `SystemMessage`, `FunctionMessage` and `ChatMessage` – `ChatMessage` takes in an arbitrary role parameter. Most of the time, you’ll just be dealing with `HumanMessage`, `AIMessage`, and `SystemMessage` Chat models accept `List[BaseMessage]` as inputs, or objects which can be coerced to messages, including `str` (converted to `HumanMessage`) and `PromptValue`. ``` AIMessage(content="The purpose of model regularization is to prevent overfitting in machine learning models. Overfitting occurs when a model becomes too complex and starts to fit the noise in the training data, leading to poor generalization on unseen data. Regularization techniques introduce additional constraints or penalties to the model's objective function, discouraging it from becoming overly complex and promoting simpler and more generalizable models. Regularization helps to strike a balance between fitting the training data well and avoiding overfitting, leading to better performance on new, unseen data.") ``` ``` The purpose of model regularization is to prevent overfitting and improve the generalization of a machine learning model. Overfitting occurs when a model is too complex and learns the noise or random variations in the training data, which leads to poor performance on new, unseen data. Regularization techniques introduce additional constraints or penalties to the model's learning process, discouraging it from fitting the noise and reducing the complexity of the model. This helps to improve the model's ability to generalize well and make accurate predictions on unseen data. ``` ``` [AIMessage(content="The purpose of model regularization is to prevent overfitting in machine learning models. Overfitting occurs when a model becomes too complex and starts to learn the noise or random fluctuations in the training data, rather than the underlying patterns or relationships. Regularization techniques add a penalty term to the model's objective function, which discourages the model from becoming too complex and helps it generalize better to new, unseen data. This improves the model's ability to make accurate predictions on new data by reducing the variance and increasing the model's overall performance.")] ``` ``` AIMessage(content='The purpose of model regularization is to prevent overfitting in machine learning models. Overfitting occurs when a model becomes too complex and starts to memorize the training data instead of learning general patterns and relationships. This leads to poor performance on new, unseen data.\n\nRegularization techniques introduce additional constraints or penalties to the model during training, discouraging it from becoming overly complex. This helps to strike a balance between fitting the training data well and generalizing to new data. Regularization techniques can include adding a penalty term to the loss function, such as L1 or L2 regularization, or using techniques like dropout or early stopping. By regularizing the model, it encourages it to learn the most relevant features and reduce the impact of noise or outliers in the data.') ``` ``` The purpose of model regularization is to prevent overfitting in machine learning models. Overfitting occurs when a model becomes too complex and starts to memorize the training data instead of learning the underlying patterns. Regularization techniques help in reducing the complexity of the model by adding a penalty to the loss function. This penalty encourages the model to have smaller weights or fewer features, making it more generalized and less prone to overfitting. The goal is to find the right balance between fitting the training data well and being able to generalize well to unseen data. ``` ``` RunLogPatch({'op': 'replace', 'path': '', 'value': {'final_output': None, 'id': '754c4143-2348-46c4-ad2b-3095913084c6', 'logs': {}, 'streamed_output': []}})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='The')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' purpose')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' of')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' model')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' regularization')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' is')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' to')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' prevent')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' a')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' machine')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' learning')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' model')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' from')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' over')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='fit')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='ting')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' the')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' training')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' data')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' and')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' improve')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' its')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' general')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='ization')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' ability')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='.')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' Over')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='fit')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='ting')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' occurs')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' when')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' a')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' model')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' becomes')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' too')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' complex')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' and')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' learns')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' to')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' fit')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' the')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' noise')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' or')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' random')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' fluctuations')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' in')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' the')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' training')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' data')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=',')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' instead')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' of')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' capturing')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' the')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' underlying')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' patterns')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' and')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' relationships')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='.')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' Regular')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='ization')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' techniques')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' introduce')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' a')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' penalty')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' term')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' to')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' the')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' model')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content="'s")})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' objective')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' function')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=',')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' which')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' discour')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='ages')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' the')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' model')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' from')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' becoming')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' too')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' complex')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='.')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' This')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' helps')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' to')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' control')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' the')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' model')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content="'s")})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' complexity')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' and')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' reduces')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' the')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' risk')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' of')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' over')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='fit')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='ting')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=',')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' leading')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' to')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' better')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' performance')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' on')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' unseen')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' data')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='.')})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='')})RunLogPatch({'op': 'replace', 'path': '/final_output', 'value': {'generations': [[{'generation_info': {'finish_reason': 'stop'}, 'message': AIMessageChunk(content="The purpose of model regularization is to prevent a machine learning model from overfitting the training data and improve its generalization ability. Overfitting occurs when a model becomes too complex and learns to fit the noise or random fluctuations in the training data, instead of capturing the underlying patterns and relationships. Regularization techniques introduce a penalty term to the model's objective function, which discourages the model from becoming too complex. This helps to control the model's complexity and reduces the risk of overfitting, leading to better performance on unseen data."), 'text': 'The purpose of model regularization is ' 'to prevent a machine learning model ' 'from overfitting the training data and ' 'improve its generalization ability. ' 'Overfitting occurs when a model becomes ' 'too complex and learns to fit the noise ' 'or random fluctuations in the training ' 'data, instead of capturing the ' 'underlying patterns and relationships. ' 'Regularization techniques introduce a ' "penalty term to the model's objective " 'function, which discourages the model ' 'from becoming too complex. This helps ' "to control the model's complexity and " 'reduces the risk of overfitting, ' 'leading to better performance on unseen ' 'data.'}]], 'llm_output': None, 'run': None}}) ``` All `ChatModel`s come with built-in LangSmith tracing. Just set the following environment variables: and any `ChatModel` invocation (whether it’s nested in a chain or not) will automatically be traced. A trace will include inputs, outputs, latency, token usage, invocation params, environment params, and more. See an example here: [https://smith.langchain.com/public/a54192ae-dd5c-4f7a-88d1-daa1eaba1af7/r](https://smith.langchain.com/public/a54192ae-dd5c-4f7a-88d1-daa1eaba1af7/r). In LangSmith you can then provide feedback for any trace, compile annotated datasets for evals, debug performance in the playground, and more. For convenience you can also treat chat models as callables. You can get chat completions by passing one or more messages to the chat model. The response will be a message. ``` AIMessage(content="J'adore la programmation.") ``` OpenAI’s chat model supports multiple messages as input. See [here](https://platform.openai.com/docs/guides/chat/chat-vs-completions) for more information. Here is an example of sending a system and user message to the chat model: ``` AIMessage(content="J'adore la programmation.") ``` You can go one step further and generate completions for multiple sets of messages using `generate`. This returns an `LLMResult` with an additional `message` parameter. This will include additional information about each generation beyond the returned message (e.g. the finish reason) and additional information about the full API call (e.g. total tokens used). ``` LLMResult(generations=[[ChatGeneration(text="J'adore programmer.", generation_info={'finish_reason': 'stop'}, message=AIMessage(content="J'adore programmer."))], [ChatGeneration(text="J'adore l'intelligence artificielle.", generation_info={'finish_reason': 'stop'}, message=AIMessage(content="J'adore l'intelligence artificielle."))]], llm_output={'token_usage': {'prompt_tokens': 53, 'completion_tokens': 18, 'total_tokens': 71}, 'model_name': 'gpt-3.5-turbo'}, run=[RunInfo(run_id=UUID('077917a9-026c-47c4-b308-77b37c3a3bfa')), RunInfo(run_id=UUID('0a70a0bf-c599-4f51-932a-c7d42202c984'))]) ``` ``` {'token_usage': {'prompt_tokens': 53, 'completion_tokens': 18, 'total_tokens': 71}, 'model_name': 'gpt-3.5-turbo'} ```

Chat models are a variation on language models. While chat models use language models under the hood, the interface they use is a bit different. Rather than using a “text in, text out” API, they use an interface where “chat messages” are the inputs and outputs. If you’d prefer not to set an environment variable you can pass the key in directly via the api key arg named parameter when initiating the chat model class: The chat model interface is based around messages rather than raw text. The types of messages currently supported in LangChain are AIMessage, HumanMessage, SystemMessage, FunctionMessage and ChatMessage – ChatMessage takes in an arbitrary role parameter. Most of the time, you’ll just be dealing with HumanMessage, AIMessage, and SystemMessage Chat models accept List[BaseMessage] as inputs, or objects which can be coerced to messages, including str (converted to HumanMessage) and PromptValue. AIMessage(content="The purpose of model regularization is to prevent overfitting in machine learning models. Overfitting occurs when a model becomes too complex and starts to fit the noise in the training data, leading to poor generalization on unseen data. Regularization techniques introduce additional constraints or penalties to the model's objective function, discouraging it from becoming overly complex and promoting simpler and more generalizable models. Regularization helps to strike a balance between fitting the training data well and avoiding overfitting, leading to better performance on new, unseen data.") The purpose of model regularization is to prevent overfitting and improve the generalization of a machine learning model. Overfitting occurs when a model is too complex and learns the noise or random variations in the training data, which leads to poor performance on new, unseen data. Regularization techniques introduce additional constraints or penalties to the model's learning process, discouraging it from fitting the noise and reducing the complexity of the model. This helps to improve the model's ability to generalize well and make accurate predictions on unseen data. [AIMessage(content="The purpose of model regularization is to prevent overfitting in machine learning models. Overfitting occurs when a model becomes too complex and starts to learn the noise or random fluctuations in the training data, rather than the underlying patterns or relationships. Regularization techniques add a penalty term to the model's objective function, which discourages the model from becoming too complex and helps it generalize better to new, unseen data. This improves the model's ability to make accurate predictions on new data by reducing the variance and increasing the model's overall performance.")] AIMessage(content='The purpose of model regularization is to prevent overfitting in machine learning models. Overfitting occurs when a model becomes too complex and starts to memorize the training data instead of learning general patterns and relationships. This leads to poor performance on new, unseen data.\n\nRegularization techniques introduce additional constraints or penalties to the model during training, discouraging it from becoming overly complex. This helps to strike a balance between fitting the training data well and generalizing to new data. Regularization techniques can include adding a penalty term to the loss function, such as L1 or L2 regularization, or using techniques like dropout or early stopping. By regularizing the model, it encourages it to learn the most relevant features and reduce the impact of noise or outliers in the data.') The purpose of model regularization is to prevent overfitting in machine learning models. Overfitting occurs when a model becomes too complex and starts to memorize the training data instead of learning the underlying patterns. Regularization techniques help in reducing the complexity of the model by adding a penalty to the loss function. This penalty encourages the model to have smaller weights or fewer features, making it more generalized and less prone to overfitting. The goal is to find the right balance between fitting the training data well and being able to generalize well to unseen data. RunLogPatch({'op': 'replace', 'path': '', 'value': {'final_output': None, 'id': '754c4143-2348-46c4-ad2b-3095913084c6', 'logs': {}, 'streamed_output': []}}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='The')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' purpose')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' of')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' model')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' regularization')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' is')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' to')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' prevent')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' a')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' machine')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' learning')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' model')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' from')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' over')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='fit')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='ting')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' the')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' training')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' data')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' and')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' improve')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' its')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' general')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='ization')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' ability')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='.')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' Over')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='fit')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='ting')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' occurs')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' when')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' a')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' model')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' becomes')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' too')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' complex')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' and')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' learns')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' to')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' fit')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' the')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' noise')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' or')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' random')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' fluctuations')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' in')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' the')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' training')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' data')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=',')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' instead')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' of')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' capturing')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' the')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' underlying')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' patterns')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' and')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' relationships')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='.')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' Regular')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='ization')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' techniques')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' introduce')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' a')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' penalty')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' term')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' to')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' the')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' model')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content="'s")}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' objective')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' function')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=',')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' which')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' discour')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='ages')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' the')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' model')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' from')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' becoming')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' too')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' complex')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='.')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' This')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' helps')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' to')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' control')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' the')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' model')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content="'s")}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' complexity')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' and')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' reduces')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' the')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' risk')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' of')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' over')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='fit')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='ting')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=',')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' leading')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' to')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' better')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' performance')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' on')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' unseen')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content=' data')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='.')}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': AIMessageChunk(content='')}) RunLogPatch({'op': 'replace', 'path': '/final_output', 'value': {'generations': [[{'generation_info': {'finish_reason': 'stop'}, 'message': AIMessageChunk(content="The purpose of model regularization is to prevent a machine learning model from overfitting the training data and improve its generalization ability. Overfitting occurs when a model becomes too complex and learns to fit the noise or random fluctuations in the training data, instead of capturing the underlying patterns and relationships. Regularization techniques introduce a penalty term to the model's objective function, which discourages the model from becoming too complex. This helps to control the model's complexity and reduces the risk of overfitting, leading to better performance on unseen data."), 'text': 'The purpose of model regularization is ' 'to prevent a machine learning model ' 'from overfitting the training data and ' 'improve its generalization ability. ' 'Overfitting occurs when a model becomes ' 'too complex and learns to fit the noise ' 'or random fluctuations in the training ' 'data, instead of capturing the ' 'underlying patterns and relationships. ' 'Regularization techniques introduce a ' "penalty term to the model's objective " 'function, which discourages the model ' 'from becoming too complex. This helps ' "to control the model's complexity and " 'reduces the risk of overfitting, ' 'leading to better performance on unseen ' 'data.'}]], 'llm_output': None, 'run': None}}) All ChatModels come with built-in LangSmith tracing. Just set the following environment variables: and any ChatModel invocation (whether it’s nested in a chain or not) will automatically be traced. A trace will include inputs, outputs, latency, token usage, invocation params, environment params, and more. See an example here: https://smith.langchain.com/public/a54192ae-dd5c-4f7a-88d1-daa1eaba1af7/r. In LangSmith you can then provide feedback for any trace, compile annotated datasets for evals, debug performance in the playground, and more. For convenience you can also treat chat models as callables. You can get chat completions by passing one or more messages to the chat model. The response will be a message. AIMessage(content="J'adore la programmation.") OpenAI’s chat model supports multiple messages as input. See here for more information. Here is an example of sending a system and user message to the chat model: AIMessage(content="J'adore la programmation.") You can go one step further and generate completions for multiple sets of messages using generate. This returns an LLMResult with an additional message parameter. This will include additional information about each generation beyond the returned message (e.g. the finish reason) and additional information about the full API call (e.g. total tokens used). LLMResult(generations=[[ChatGeneration(text="J'adore programmer.", generation_info={'finish_reason': 'stop'}, message=AIMessage(content="J'adore programmer."))], [ChatGeneration(text="J'adore l'intelligence artificielle.", generation_info={'finish_reason': 'stop'}, message=AIMessage(content="J'adore l'intelligence artificielle."))]], llm_output={'token_usage': {'prompt_tokens': 53, 'completion_tokens': 18, 'total_tokens': 71}, 'model_name': 'gpt-3.5-turbo'}, run=[RunInfo(run_id=UUID('077917a9-026c-47c4-b308-77b37c3a3bfa')), RunInfo(run_id=UUID('0a70a0bf-c599-4f51-932a-c7d42202c984'))]) {'token_usage': {'prompt_tokens': 53, 'completion_tokens': 18, 'total_tokens': 71}, 'model_name': 'gpt-3.5-turbo'}

https://python.langchain.com/docs/modules/model_io/chat/structured_output/

## \[beta\] Structured Output It is often crucial to have LLMs return structured output. This is because oftentimes the outputs of the LLMs are used in downstream applications, where specific arguments are required. Having the LLM return structured output reliably is necessary for that. There are a few different high level strategies that are used to do this: * Prompting: This is when you ask the LLM (very nicely) to return output in the desired format (JSON, XML). This is nice because it works with all LLMs. It is not nice because there is no guarantee that the LLM returns the output in the right format. * Function calling: This is when the LLM is fine-tuned to be able to not just generate a completion, but also generate a function call. The functions the LLM can call are generally passed as extra parameters to the model API. The function names and descriptions should be treated as part of the prompt (they usually count against token counts, and are used by the LLM to decide what to do). * Tool calling: A technique similar to function calling, but it allows the LLM to call multiple functions at the same time. * JSON mode: This is when the LLM is guaranteed to return JSON. Different models may support different variants of these, with slightly different parameters. In order to make it easy to get LLMs to return structured output, we have added a common interface to LangChain models: `.with_structured_output`. By invoking this method (and passing in a JSON schema or a Pydantic model) the model will add whatever model parameters + output parsers are necessary to get back the structured output. There may be more than one way to do this (e.g., function calling vs JSON mode) - you can configure which method to use by passing into that method. Let’s look at some examples of this in action! We will use Pydantic to easily structure the response schema. ``` from langchain_core.pydantic_v1 import BaseModel, Field ``` ``` class Joke(BaseModel): setup: str = Field(description="The setup of the joke") punchline: str = Field(description="The punchline to the joke") ``` ## OpenAI[​](#openai "Direct link to OpenAI") OpenAI exposes a few different ways to get structured outputs. [API reference](https://api.python.langchain.com/en/latest/chat_models/langchain_openai.chat_models.base.ChatOpenAI.html#langchain_openai.chat_models.base.ChatOpenAI.with_structured_output) ``` from langchain_openai import ChatOpenAI ``` #### Tool/function Calling[​](#toolfunction-calling "Direct link to Tool/function Calling") By default, we will use `function_calling` ``` model = ChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0)structured_llm = model.with_structured_output(Joke) ``` ``` structured_llm.invoke("Tell me a joke about cats") ``` ``` Joke(setup='Why was the cat sitting on the computer?', punchline='It wanted to keep an eye on the mouse!') ``` #### JSON Mode[​](#json-mode "Direct link to JSON Mode") We also support JSON mode. Note that we need to specify in the prompt the format that it should respond in. ``` structured_llm = model.with_structured_output(Joke, method="json_mode") ``` ``` structured_llm.invoke( "Tell me a joke about cats, respond in JSON with `setup` and `punchline` keys") ``` ``` Joke(setup="Why don't cats play poker in the jungle?", punchline='Too many cheetahs!') ``` ## Fireworks[​](#fireworks "Direct link to Fireworks") [Fireworks](https://fireworks.ai/) similarly supports function calling and JSON mode for select models. [API reference](https://api.python.langchain.com/en/latest/chat_models/langchain_fireworks.chat_models.ChatFireworks.html#langchain_fireworks.chat_models.ChatFireworks.with_structured_output) ``` from langchain_fireworks import ChatFireworks ``` #### Tool/function Calling[​](#toolfunction-calling-1 "Direct link to Tool/function Calling") By default, we will use `function_calling` ``` model = ChatFireworks(model="accounts/fireworks/models/firefunction-v1")structured_llm = model.with_structured_output(Joke) ``` ``` structured_llm.invoke("Tell me a joke about cats") ``` ``` Joke(setup="Why don't cats play poker in the jungle?", punchline='Too many cheetahs!') ``` #### JSON Mode[​](#json-mode-1 "Direct link to JSON Mode") We also support JSON mode. Note that we need to specify in the prompt the format that it should respond in. ``` structured_llm = model.with_structured_output(Joke, method="json_mode") ``` ``` structured_llm.invoke( "Tell me a joke about dogs, respond in JSON with `setup` and `punchline` keys") ``` ``` Joke(setup='Why did the dog sit in the shade?', punchline='To avoid getting burned.') ``` ## Mistral[​](#mistral "Direct link to Mistral") We also support structured output with Mistral models, although we only support function calling. [API reference](https://api.python.langchain.com/en/latest/chat_models/langchain_mistralai.chat_models.ChatMistralAI.html#langchain_mistralai.chat_models.ChatMistralAI.with_structured_output) ``` from langchain_mistralai import ChatMistralAI ``` ``` model = ChatMistralAI(model="mistral-large-latest")structured_llm = model.with_structured_output(Joke) ``` ``` structured_llm.invoke("Tell me a joke about cats") ``` ## Together[​](#together "Direct link to Together") Since [TogetherAI](https://www.together.ai/) is just a drop in replacement for OpenAI, we can just use the OpenAI integration ``` import osfrom langchain_openai import ChatOpenAI ``` ``` model = ChatOpenAI( base_url="https://api.together.xyz/v1", api_key=os.environ["TOGETHER_API_KEY"], model="mistralai/Mixtral-8x7B-Instruct-v0.1",)structured_llm = model.with_structured_output(Joke) ``` ``` structured_llm.invoke("Tell me a joke about cats") ``` ``` Joke(setup='Why did the cat sit on the computer?', punchline='To keep an eye on the mouse!') ``` ## Groq[​](#groq "Direct link to Groq") Groq provides an OpenAI-compatible function calling API. [API reference](https://api.python.langchain.com/en/latest/chat_models/langchain_groq.chat_models.ChatGroq.html#langchain_groq.chat_models.ChatGroq.with_structured_output) ``` from langchain_groq import ChatGroq ``` #### Tool/function Calling[​](#toolfunction-calling-2 "Direct link to Tool/function Calling") By default, we will use `function_calling` ``` model = ChatGroq()structured_llm = model.with_structured_output(Joke) ``` ``` /Users/reag/src/langchain/libs/core/langchain_core/_api/beta_decorator.py:87: LangChainBetaWarning: The function `with_structured_output` is in beta. It is actively being worked on, so the API may change. warn_beta( ``` ``` structured_llm.invoke("Tell me a joke about cats") ``` ``` Joke(setup="Why don't cats play poker in the jungle?", punchline='Too many cheetahs!') ``` #### JSON Mode[​](#json-mode-2 "Direct link to JSON Mode") We also support JSON mode. Note that we need to specify in the prompt the format that it should respond in. ``` structured_llm = model.with_structured_output(Joke, method="json_mode") ``` ``` structured_llm.invoke( "Tell me a joke about cats, respond in JSON with `setup` and `punchline` keys") ``` ``` Joke(setup="Why don't cats play poker in the jungle?", punchline='Too many cheetahs!') ``` ## Anthropic[​](#anthropic "Direct link to Anthropic") Anthropic’s tool-calling API can be used for structuring outputs. Note that there is currently no way to force a tool-call via the API, so prompting the model correctly is still important. [API reference](https://api.python.langchain.com/en/latest/chat_models/langchain_anthropic.chat_models.ChatAnthropic.html#langchain_anthropic.chat_models.ChatAnthropic.with_structured_output) ``` from langchain_anthropic import ChatAnthropicmodel = ChatAnthropic(model="claude-3-opus-20240229", temperature=0)structured_llm = model.with_structured_output(Joke)structured_llm.invoke("Tell me a joke about cats. Make sure to call the Joke function.") ``` ``` Joke(setup='What do you call a cat that loves to bowl?', punchline='An alley cat!') ``` ## Google Vertex AI[​](#google-vertex-ai "Direct link to Google Vertex AI") Google’s Gemini models support [function-calling](https://ai.google.dev/docs/function_calling), which we can access via Vertex AI and use for structuring outputs. [API reference](https://api.python.langchain.com/en/latest/chat_models/langchain_google_vertexai.chat_models.ChatVertexAI.html#langchain_google_vertexai.chat_models.ChatVertexAI.with_structured_output) ``` from langchain_google_vertexai import ChatVertexAIllm = ChatVertexAI(model="gemini-pro", temperature=0)structured_llm = llm.with_structured_output(Joke)structured_llm.invoke("Tell me a joke about cats") ``` ``` Joke(setup='A cat-ch', punchline='What do you call a cat that loves to play fetch?') ```

[beta] Structured Output It is often crucial to have LLMs return structured output. This is because oftentimes the outputs of the LLMs are used in downstream applications, where specific arguments are required. Having the LLM return structured output reliably is necessary for that. There are a few different high level strategies that are used to do this: Prompting: This is when you ask the LLM (very nicely) to return output in the desired format (JSON, XML). This is nice because it works with all LLMs. It is not nice because there is no guarantee that the LLM returns the output in the right format. Function calling: This is when the LLM is fine-tuned to be able to not just generate a completion, but also generate a function call. The functions the LLM can call are generally passed as extra parameters to the model API. The function names and descriptions should be treated as part of the prompt (they usually count against token counts, and are used by the LLM to decide what to do). Tool calling: A technique similar to function calling, but it allows the LLM to call multiple functions at the same time. JSON mode: This is when the LLM is guaranteed to return JSON. Different models may support different variants of these, with slightly different parameters. In order to make it easy to get LLMs to return structured output, we have added a common interface to LangChain models: .with_structured_output. By invoking this method (and passing in a JSON schema or a Pydantic model) the model will add whatever model parameters + output parsers are necessary to get back the structured output. There may be more than one way to do this (e.g., function calling vs JSON mode) - you can configure which method to use by passing into that method. Let’s look at some examples of this in action! We will use Pydantic to easily structure the response schema. from langchain_core.pydantic_v1 import BaseModel, Field class Joke(BaseModel): setup: str = Field(description="The setup of the joke") punchline: str = Field(description="The punchline to the joke") OpenAI​ OpenAI exposes a few different ways to get structured outputs. API reference from langchain_openai import ChatOpenAI Tool/function Calling​ By default, we will use function_calling model = ChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0) structured_llm = model.with_structured_output(Joke) structured_llm.invoke("Tell me a joke about cats") Joke(setup='Why was the cat sitting on the computer?', punchline='It wanted to keep an eye on the mouse!') JSON Mode​ We also support JSON mode. Note that we need to specify in the prompt the format that it should respond in. structured_llm = model.with_structured_output(Joke, method="json_mode") structured_llm.invoke( "Tell me a joke about cats, respond in JSON with `setup` and `punchline` keys" ) Joke(setup="Why don't cats play poker in the jungle?", punchline='Too many cheetahs!') Fireworks​ Fireworks similarly supports function calling and JSON mode for select models. API reference from langchain_fireworks import ChatFireworks Tool/function Calling​ By default, we will use function_calling model = ChatFireworks(model="accounts/fireworks/models/firefunction-v1") structured_llm = model.with_structured_output(Joke) structured_llm.invoke("Tell me a joke about cats") Joke(setup="Why don't cats play poker in the jungle?", punchline='Too many cheetahs!') JSON Mode​ We also support JSON mode. Note that we need to specify in the prompt the format that it should respond in. structured_llm = model.with_structured_output(Joke, method="json_mode") structured_llm.invoke( "Tell me a joke about dogs, respond in JSON with `setup` and `punchline` keys" ) Joke(setup='Why did the dog sit in the shade?', punchline='To avoid getting burned.') Mistral​ We also support structured output with Mistral models, although we only support function calling. API reference from langchain_mistralai import ChatMistralAI model = ChatMistralAI(model="mistral-large-latest") structured_llm = model.with_structured_output(Joke) structured_llm.invoke("Tell me a joke about cats") Together​ Since TogetherAI is just a drop in replacement for OpenAI, we can just use the OpenAI integration import os from langchain_openai import ChatOpenAI model = ChatOpenAI( base_url="https://api.together.xyz/v1", api_key=os.environ["TOGETHER_API_KEY"], model="mistralai/Mixtral-8x7B-Instruct-v0.1", ) structured_llm = model.with_structured_output(Joke) structured_llm.invoke("Tell me a joke about cats") Joke(setup='Why did the cat sit on the computer?', punchline='To keep an eye on the mouse!') Groq​ Groq provides an OpenAI-compatible function calling API. API reference from langchain_groq import ChatGroq Tool/function Calling​ By default, we will use function_calling model = ChatGroq() structured_llm = model.with_structured_output(Joke) /Users/reag/src/langchain/libs/core/langchain_core/_api/beta_decorator.py:87: LangChainBetaWarning: The function `with_structured_output` is in beta. It is actively being worked on, so the API may change. warn_beta( structured_llm.invoke("Tell me a joke about cats") Joke(setup="Why don't cats play poker in the jungle?", punchline='Too many cheetahs!') JSON Mode​ We also support JSON mode. Note that we need to specify in the prompt the format that it should respond in. structured_llm = model.with_structured_output(Joke, method="json_mode") structured_llm.invoke( "Tell me a joke about cats, respond in JSON with `setup` and `punchline` keys" ) Joke(setup="Why don't cats play poker in the jungle?", punchline='Too many cheetahs!') Anthropic​ Anthropic’s tool-calling API can be used for structuring outputs. Note that there is currently no way to force a tool-call via the API, so prompting the model correctly is still important. API reference from langchain_anthropic import ChatAnthropic model = ChatAnthropic(model="claude-3-opus-20240229", temperature=0) structured_llm = model.with_structured_output(Joke) structured_llm.invoke("Tell me a joke about cats. Make sure to call the Joke function.") Joke(setup='What do you call a cat that loves to bowl?', punchline='An alley cat!') Google Vertex AI​ Google’s Gemini models support function-calling, which we can access via Vertex AI and use for structuring outputs. API reference from langchain_google_vertexai import ChatVertexAI llm = ChatVertexAI(model="gemini-pro", temperature=0) structured_llm = llm.with_structured_output(Joke) structured_llm.invoke("Tell me a joke about cats") Joke(setup='A cat-ch', punchline='What do you call a cat that loves to play fetch?')

https://python.langchain.com/docs/modules/model_io/chat/token_usage_tracking/

This notebook goes over how to track your token usage for specific calls. A number of model providers return token usage information as part of the chat generation response. When available, this is included in the [AIMessage.response\_metadata](https://python.langchain.com/docs/modules/model_io/chat/response_metadata/). Here’s an example with OpenAI: ``` {'token_usage': {'completion_tokens': 225, 'prompt_tokens': 17, 'total_tokens': 242}, 'model_name': 'gpt-4-turbo', 'system_fingerprint': 'fp_76f018034d', 'finish_reason': 'stop', 'logprobs': None} ``` ``` {'id': 'msg_01P61rdHbapEo6h3fjpfpCQT', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 17, 'output_tokens': 306}} ``` There are also some API-specific callback context managers that allow you to track token usage across multiple calls. It is currently only implemented for the OpenAI API and Bedrock Anthropic API. Let’s first look at an extremely simple example of tracking token usage for a single Chat model call. ``` Tokens Used: 26 Prompt Tokens: 11 Completion Tokens: 15Successful Requests: 1Total Cost (USD): $0.00056 ``` Anything inside the context manager will get tracked. Here’s an example of using it to track multiple calls in sequence. If a chain or agent with multiple steps in it is used, it will track all those steps. ``` from langchain.agents import AgentExecutor, create_tool_calling_agent, load_toolsfrom langchain_core.prompts import ChatPromptTemplateprompt = ChatPromptTemplate.from_messages( [ ("system", "You're a helpful assistant"), ("human", "{input}"), ("placeholder", "{agent_scratchpad}"), ])tools = load_tools(["wikipedia"])agent = create_tool_calling_agent(llm, tools, prompt)agent_executor = AgentExecutor( agent=agent, tools=tools, verbose=True, stream_runnable=False) ``` ``` > Entering new AgentExecutor chain...Invoking: `wikipedia` with `Hummingbird`Page: HummingbirdSummary: Hummingbirds are birds native to the Americas and comprise the biological family Trochilidae. With approximately 366 species and 113 genera, they occur from Alaska to Tierra del Fuego, but most species are found in Central and South America. As of 2024, 21 hummingbird species are listed as endangered or critically endangered, with numerous species declining in population.Hummingbirds have varied specialized characteristics to enable rapid, maneuverable flight: exceptional metabolic capacity, adaptations to high altitude, sensitive visual and communication abilities, and long-distance migration in some species. Among all birds, male hummingbirds have the widest diversity of plumage color, particularly in blues, greens, and purples. Hummingbirds are the smallest mature birds, measuring 7.5–13 cm (3–5 in) in length. The smallest is the 5 cm (2.0 in) bee hummingbird, which weighs less than 2.0 g (0.07 oz), and the largest is the 23 cm (9 in) giant hummingbird, weighing 18–24 grams (0.63–0.85 oz). Noted for long beaks, hummingbirds are specialized for feeding on flower nectar, but all species also consume small insects.They are known as hummingbirds because of the humming sound created by their beating wings, which flap at high frequencies audible to other birds and humans. They hover at rapid wing-flapping rates, which vary from around 12 beats per second in the largest species to 80 per second in small hummingbirds.Hummingbirds have the highest mass-specific metabolic rate of any homeothermic animal. To conserve energy when food is scarce and at night when not foraging, they can enter torpor, a state similar to hibernation, and slow their metabolic rate to 1⁄15 of its normal rate. While most hummingbirds do not migrate, the rufous hummingbird has one of the longest migrations among birds, traveling twice per year between Alaska and Mexico, a distance of about 3,900 miles (6,300 km).Hummingbirds split from their sister group, the swifts and treeswifts, around 42 million years ago. The oldest known fossil hummingbird is Eurotrochilus, from the Rupelian Stage of Early Oligocene Europe.Page: Bee hummingbirdSummary: The bee hummingbird, zunzuncito or Helena hummingbird (Mellisuga helenae) is a species of hummingbird, native to the island of Cuba in the Caribbean. It is the smallest known bird. The bee hummingbird feeds on nectar of flowers and bugs found in Cuba.Page: Hummingbird cakeSummary: Hummingbird cake is a banana-pineapple spice cake originating in Jamaica and a popular dessert in the southern United States since the 1970s. Ingredients include flour, sugar, salt, vegetable oil, ripe banana, pineapple, cinnamon, pecans, vanilla extract, eggs, and leavening agent. It is often served with cream cheese frosting.Invoking: `wikipedia` with `Fastest bird`Page: Fastest animalsSummary: This is a list of the fastest animals in the world, by types of animal.Page: List of birds by flight speedSummary: This is a list of the fastest flying birds in the world. A bird's velocity is necessarily variable; a hunting bird will reach much greater speeds while diving to catch prey than when flying horizontally. The bird that can achieve the greatest airspeed is the peregrine falcon, able to exceed 320 km/h (200 mph) in its dives. A close relative of the common swift, the white-throated needletail (Hirundapus caudacutus), is commonly reported as the fastest bird in level flight with a reported top speed of 169 km/h (105 mph). This record remains unconfirmed as the measurement methods have never been published or verified. The record for the fastest confirmed level flight by a bird is 111.5 km/h (69.3 mph) held by the common swift.Page: OstrichSummary: Ostriches are large flightless birds. They are the heaviest and largest living birds, with adult common ostriches weighing anywhere between 63.5 and 145 kilograms and laying the largest eggs of any living land animal. With the ability to run at 70 km/h (43.5 mph), they are the fastest birds on land. They are farmed worldwide, with significant industries in the Philippines and in Namibia. Ostrich leather is a lucrative commodity, and the large feathers are used as plumes for the decoration of ceremonial headgear. Ostrich eggs have been used by humans for millennia.Ostriches are of the genus Struthio in the order Struthioniformes, part of the infra-class Palaeognathae, a diverse group of flightless birds also known as ratites that includes the emus, rheas, cassowaries, kiwis and the extinct elephant birds and moas. There are two living species of ostrich: the common ostrich, native to large areas of sub-Saharan Africa, and the Somali ostrich, native to the Horn of Africa. The common ostrich was historically native to the Arabian Peninsula, and ostriches were present across Asia as far east as China and Mongolia during the Late Pleistocene and possibly into the Holocene.### Hummingbird's Scientific NameThe scientific name for the bee hummingbird, which is the smallest known bird and a species of hummingbird, is **Mellisuga helenae**. It is native to Cuba.### Fastest Bird SpeciesThe fastest bird in terms of airspeed is the **peregrine falcon**, which can exceed speeds of 320 km/h (200 mph) during its diving flight. In level flight, the fastest confirmed speed is held by the **common swift**, which can fly at 111.5 km/h (69.3 mph).> Finished chain.Total Tokens: 1583Prompt Tokens: 1412Completion Tokens: 171Total Cost (USD): $0.019250000000000003 ``` ``` Tokens Used: 0 Prompt Tokens: 0 Completion Tokens: 0Successful Requests: 2Total Cost (USD): $0.0 ```

This notebook goes over how to track your token usage for specific calls. A number of model providers return token usage information as part of the chat generation response. When available, this is included in the AIMessage.response_metadata. Here’s an example with OpenAI: {'token_usage': {'completion_tokens': 225, 'prompt_tokens': 17, 'total_tokens': 242}, 'model_name': 'gpt-4-turbo', 'system_fingerprint': 'fp_76f018034d', 'finish_reason': 'stop', 'logprobs': None} {'id': 'msg_01P61rdHbapEo6h3fjpfpCQT', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 17, 'output_tokens': 306}} There are also some API-specific callback context managers that allow you to track token usage across multiple calls. It is currently only implemented for the OpenAI API and Bedrock Anthropic API. Let’s first look at an extremely simple example of tracking token usage for a single Chat model call. Tokens Used: 26 Prompt Tokens: 11 Completion Tokens: 15 Successful Requests: 1 Total Cost (USD): $0.00056 Anything inside the context manager will get tracked. Here’s an example of using it to track multiple calls in sequence. If a chain or agent with multiple steps in it is used, it will track all those steps. from langchain.agents import AgentExecutor, create_tool_calling_agent, load_tools from langchain_core.prompts import ChatPromptTemplate prompt = ChatPromptTemplate.from_messages( [ ("system", "You're a helpful assistant"), ("human", "{input}"), ("placeholder", "{agent_scratchpad}"), ] ) tools = load_tools(["wikipedia"]) agent = create_tool_calling_agent(llm, tools, prompt) agent_executor = AgentExecutor( agent=agent, tools=tools, verbose=True, stream_runnable=False ) > Entering new AgentExecutor chain... Invoking: `wikipedia` with `Hummingbird` Page: Hummingbird Summary: Hummingbirds are birds native to the Americas and comprise the biological family Trochilidae. With approximately 366 species and 113 genera, they occur from Alaska to Tierra del Fuego, but most species are found in Central and South America. As of 2024, 21 hummingbird species are listed as endangered or critically endangered, with numerous species declining in population.Hummingbirds have varied specialized characteristics to enable rapid, maneuverable flight: exceptional metabolic capacity, adaptations to high altitude, sensitive visual and communication abilities, and long-distance migration in some species. Among all birds, male hummingbirds have the widest diversity of plumage color, particularly in blues, greens, and purples. Hummingbirds are the smallest mature birds, measuring 7.5–13 cm (3–5 in) in length. The smallest is the 5 cm (2.0 in) bee hummingbird, which weighs less than 2.0 g (0.07 oz), and the largest is the 23 cm (9 in) giant hummingbird, weighing 18–24 grams (0.63–0.85 oz). Noted for long beaks, hummingbirds are specialized for feeding on flower nectar, but all species also consume small insects. They are known as hummingbirds because of the humming sound created by their beating wings, which flap at high frequencies audible to other birds and humans. They hover at rapid wing-flapping rates, which vary from around 12 beats per second in the largest species to 80 per second in small hummingbirds. Hummingbirds have the highest mass-specific metabolic rate of any homeothermic animal. To conserve energy when food is scarce and at night when not foraging, they can enter torpor, a state similar to hibernation, and slow their metabolic rate to 1⁄15 of its normal rate. While most hummingbirds do not migrate, the rufous hummingbird has one of the longest migrations among birds, traveling twice per year between Alaska and Mexico, a distance of about 3,900 miles (6,300 km). Hummingbirds split from their sister group, the swifts and treeswifts, around 42 million years ago. The oldest known fossil hummingbird is Eurotrochilus, from the Rupelian Stage of Early Oligocene Europe. Page: Bee hummingbird Summary: The bee hummingbird, zunzuncito or Helena hummingbird (Mellisuga helenae) is a species of hummingbird, native to the island of Cuba in the Caribbean. It is the smallest known bird. The bee hummingbird feeds on nectar of flowers and bugs found in Cuba. Page: Hummingbird cake Summary: Hummingbird cake is a banana-pineapple spice cake originating in Jamaica and a popular dessert in the southern United States since the 1970s. Ingredients include flour, sugar, salt, vegetable oil, ripe banana, pineapple, cinnamon, pecans, vanilla extract, eggs, and leavening agent. It is often served with cream cheese frosting. Invoking: `wikipedia` with `Fastest bird` Page: Fastest animals Summary: This is a list of the fastest animals in the world, by types of animal. Page: List of birds by flight speed Summary: This is a list of the fastest flying birds in the world. A bird's velocity is necessarily variable; a hunting bird will reach much greater speeds while diving to catch prey than when flying horizontally. The bird that can achieve the greatest airspeed is the peregrine falcon, able to exceed 320 km/h (200 mph) in its dives. A close relative of the common swift, the white-throated needletail (Hirundapus caudacutus), is commonly reported as the fastest bird in level flight with a reported top speed of 169 km/h (105 mph). This record remains unconfirmed as the measurement methods have never been published or verified. The record for the fastest confirmed level flight by a bird is 111.5 km/h (69.3 mph) held by the common swift. Page: Ostrich Summary: Ostriches are large flightless birds. They are the heaviest and largest living birds, with adult common ostriches weighing anywhere between 63.5 and 145 kilograms and laying the largest eggs of any living land animal. With the ability to run at 70 km/h (43.5 mph), they are the fastest birds on land. They are farmed worldwide, with significant industries in the Philippines and in Namibia. Ostrich leather is a lucrative commodity, and the large feathers are used as plumes for the decoration of ceremonial headgear. Ostrich eggs have been used by humans for millennia. Ostriches are of the genus Struthio in the order Struthioniformes, part of the infra-class Palaeognathae, a diverse group of flightless birds also known as ratites that includes the emus, rheas, cassowaries, kiwis and the extinct elephant birds and moas. There are two living species of ostrich: the common ostrich, native to large areas of sub-Saharan Africa, and the Somali ostrich, native to the Horn of Africa. The common ostrich was historically native to the Arabian Peninsula, and ostriches were present across Asia as far east as China and Mongolia during the Late Pleistocene and possibly into the Holocene.### Hummingbird's Scientific Name The scientific name for the bee hummingbird, which is the smallest known bird and a species of hummingbird, is **Mellisuga helenae**. It is native to Cuba. ### Fastest Bird Species The fastest bird in terms of airspeed is the **peregrine falcon**, which can exceed speeds of 320 km/h (200 mph) during its diving flight. In level flight, the fastest confirmed speed is held by the **common swift**, which can fly at 111.5 km/h (69.3 mph). > Finished chain. Total Tokens: 1583 Prompt Tokens: 1412 Completion Tokens: 171 Total Cost (USD): $0.019250000000000003 Tokens Used: 0 Prompt Tokens: 0 Completion Tokens: 0 Successful Requests: 2 Total Cost (USD): $0.0

https://python.langchain.com/docs/modules/model_io/concepts/

## Concepts The core element of any language model application is...the model. LangChain gives you the building blocks to interface with any language model. Everything in this section is about making it easier to work with models. This largely involves a clear interface for what a model is, helper utils for constructing inputs to models, and helper utils for working with the outputs of models. ## Models[​](#models "Direct link to Models") There are two main types of models that LangChain integrates with: LLMs and Chat Models. These are defined by their input and output types. ### LLMs[​](#llms "Direct link to LLMs") LLMs in LangChain refer to pure text completion models. The APIs they wrap take a string prompt as input and output a string completion. OpenAI's GPT-3 is implemented as an LLM. ### Chat Models[​](#chat-models "Direct link to Chat Models") Chat models are often backed by LLMs but tuned specifically for having conversations. Crucially, their provider APIs use a different interface than pure text completion models. Instead of a single string, they take a list of chat messages as input and they return an AI message as output. See the section below for more details on what exactly a message consists of. GPT-4 and Anthropic's Claude-2 are both implemented as chat models. ### Considerations[​](#considerations "Direct link to Considerations") These two API types have pretty different input and output schemas. This means that best way to interact with them may be quite different. Although LangChain makes it possible to treat them interchangeably, that doesn't mean you **should**. In particular, the prompting strategies for LLMs vs ChatModels may be quite different. This means that you will want to make sure the prompt you are using is designed for the model type you are working with. Additionally, not all models are the same. Different models have different prompting strategies that work best for them. For example, Anthropic's models work best with XML while OpenAI's work best with JSON. This means that the prompt you use for one model may not transfer to other ones. LangChain provides a lot of default prompts, however these are not guaranteed to work well with the model you are using. Historically speaking, most prompts work well with OpenAI but are not heavily tested on other models. This is something we are working to address, but it is something you should keep in mind. ## Messages[​](#messages "Direct link to Messages") ChatModels take a list of messages as input and return a message. There are a few different types of messages. All messages have a `role` and a `content` property. The `role` describes WHO is saying the message. LangChain has different message classes for different roles. The `content` property describes the content of the message. This can be a few different things: * A string (most models are this way) * A List of dictionaries (this is used for multi-modal input, where the dictionary contains information about that input type and that input location) In addition, messages have an `additional_kwargs` property. This is where additional information about messages can be passed. This is largely used for input parameters that are _provider specific_ and not general. The best known example of this is `function_call` from OpenAI. ### HumanMessage[​](#humanmessage "Direct link to HumanMessage") This represents a message from the user. Generally consists only of content. ### AIMessage[​](#aimessage "Direct link to AIMessage") This represents a message from the model. This may have `additional_kwargs` in it - for example `functional_call` if using OpenAI Function calling. ### SystemMessage[​](#systemmessage "Direct link to SystemMessage") This represents a system message. Only some models support this. This tells the model how to behave. This generally only consists of content. ### FunctionMessage[​](#functionmessage "Direct link to FunctionMessage") This represents the result of a function call. In addition to `role` and `content`, this message has a `name` parameter which conveys the name of the function that was called to produce this result. ### ToolMessage[​](#toolmessage "Direct link to ToolMessage") This represents the result of a tool call. This is distinct from a FunctionMessage in order to match OpenAI's `function` and `tool` message types. In addition to `role` and `content`, this message has a `tool_call_id` parameter which conveys the id of the call to the tool that was called to produce this result. ## Prompts[​](#prompts "Direct link to Prompts") The inputs to language models are often called prompts. Oftentimes, the user input from your app is not the direct input to the model. Rather, their input is transformed in some way to produce the string or list of messages that does go into the model. The objects that take user input and transform it into the final string or messages are known as "Prompt Templates". LangChain provides several abstractions to make working with prompts easier. ### PromptValue[​](#promptvalue "Direct link to PromptValue") ChatModels and LLMs take different input types. PromptValue is a class designed to be interoperable between the two. It exposes a method to be cast to a string (to work with LLMs) and another to be cast to a list of messages (to work with ChatModels). ### PromptTemplate[​](#prompttemplate "Direct link to PromptTemplate") [This](https://python.langchain.com/docs/modules/model_io/prompts/quick_start/#prompttemplate) is an example of a prompt template. This consists of a template string. This string is then formatted with user inputs to produce a final string. ### MessagePromptTemplate[​](#messageprompttemplate "Direct link to MessagePromptTemplate") This type of template consists of a template **message** - meaning a specific role and a PromptTemplate. This PromptTemplate is then formatted with user inputs to produce a final string that becomes the `content` of this message. #### HumanMessagePromptTemplate[​](#humanmessageprompttemplate "Direct link to HumanMessagePromptTemplate") This is MessagePromptTemplate that produces a HumanMessage. #### AIMessagePromptTemplate[​](#aimessageprompttemplate "Direct link to AIMessagePromptTemplate") This is MessagePromptTemplate that produces an AIMessage. #### SystemMessagePromptTemplate[​](#systemmessageprompttemplate "Direct link to SystemMessagePromptTemplate") This is MessagePromptTemplate that produces a SystemMessage. ### MessagesPlaceholder[​](#messagesplaceholder "Direct link to MessagesPlaceholder") Oftentimes inputs to prompts can be a list of messages. This is when you would use a MessagesPlaceholder. These objects are parameterized by a `variable_name` argument. The input with the same value as this `variable_name` value should be a list of messages. ### ChatPromptTemplate[​](#chatprompttemplate "Direct link to ChatPromptTemplate") [This](https://python.langchain.com/docs/modules/model_io/prompts/quick_start/#chatprompttemplate) is an example of a prompt template. This consists of a list of MessagePromptTemplates or MessagePlaceholders. These are then formatted with user inputs to produce a final list of messages. ## Output Parsers[​](#output-parsers "Direct link to Output Parsers") The output of models are either strings or a message. Oftentimes, the string or messages contains information formatted in a specific format to be used downstream (e.g. a comma separated list, or JSON blob). Output parsers are responsible for taking in the output of a model and transforming it into a more usable form. These generally work on the `content` of the output message, but occasionally work on values in the `additional_kwargs` field. ### StrOutputParser[​](#stroutputparser "Direct link to StrOutputParser") This is a simple output parser that just converts the output of a language model (LLM or ChatModel) into a string. If the model is an LLM (and therefore outputs a string) it just passes that string through. If the output is a ChatModel (and therefore outputs a message) it passes through the `.content` attribute of the message. ### OpenAI Functions Parsers[​](#openai-functions-parsers "Direct link to OpenAI Functions Parsers") There are a few parsers dedicated to working with OpenAI function calling. They take the output of the `function_call` and `arguments` parameters (which are inside `additional_kwargs`) and work with those, largely ignoring content. ### Agent Output Parsers[​](#agent-output-parsers "Direct link to Agent Output Parsers") [Agents](https://python.langchain.com/docs/modules/agents/) are systems that use language models to determine what steps to take. The output of a language model therefore needs to be parsed into some schema that can represent what actions (if any) are to be taken. AgentOutputParsers are responsible for taking raw LLM or ChatModel output and converting it to that schema. The logic inside these output parsers can differ depending on the model and prompting strategy being used.

Concepts The core element of any language model application is...the model. LangChain gives you the building blocks to interface with any language model. Everything in this section is about making it easier to work with models. This largely involves a clear interface for what a model is, helper utils for constructing inputs to models, and helper utils for working with the outputs of models. Models​ There are two main types of models that LangChain integrates with: LLMs and Chat Models. These are defined by their input and output types. LLMs​ LLMs in LangChain refer to pure text completion models. The APIs they wrap take a string prompt as input and output a string completion. OpenAI's GPT-3 is implemented as an LLM. Chat Models​ Chat models are often backed by LLMs but tuned specifically for having conversations. Crucially, their provider APIs use a different interface than pure text completion models. Instead of a single string, they take a list of chat messages as input and they return an AI message as output. See the section below for more details on what exactly a message consists of. GPT-4 and Anthropic's Claude-2 are both implemented as chat models. Considerations​ These two API types have pretty different input and output schemas. This means that best way to interact with them may be quite different. Although LangChain makes it possible to treat them interchangeably, that doesn't mean you should. In particular, the prompting strategies for LLMs vs ChatModels may be quite different. This means that you will want to make sure the prompt you are using is designed for the model type you are working with. Additionally, not all models are the same. Different models have different prompting strategies that work best for them. For example, Anthropic's models work best with XML while OpenAI's work best with JSON. This means that the prompt you use for one model may not transfer to other ones. LangChain provides a lot of default prompts, however these are not guaranteed to work well with the model you are using. Historically speaking, most prompts work well with OpenAI but are not heavily tested on other models. This is something we are working to address, but it is something you should keep in mind. Messages​ ChatModels take a list of messages as input and return a message. There are a few different types of messages. All messages have a role and a content property. The role describes WHO is saying the message. LangChain has different message classes for different roles. The content property describes the content of the message. This can be a few different things: A string (most models are this way) A List of dictionaries (this is used for multi-modal input, where the dictionary contains information about that input type and that input location) In addition, messages have an additional_kwargs property. This is where additional information about messages can be passed. This is largely used for input parameters that are provider specific and not general. The best known example of this is function_call from OpenAI. HumanMessage​ This represents a message from the user. Generally consists only of content. AIMessage​ This represents a message from the model. This may have additional_kwargs in it - for example functional_call if using OpenAI Function calling. SystemMessage​ This represents a system message. Only some models support this. This tells the model how to behave. This generally only consists of content. FunctionMessage​ This represents the result of a function call. In addition to role and content, this message has a name parameter which conveys the name of the function that was called to produce this result. ToolMessage​ This represents the result of a tool call. This is distinct from a FunctionMessage in order to match OpenAI's function and tool message types. In addition to role and content, this message has a tool_call_id parameter which conveys the id of the call to the tool that was called to produce this result. Prompts​ The inputs to language models are often called prompts. Oftentimes, the user input from your app is not the direct input to the model. Rather, their input is transformed in some way to produce the string or list of messages that does go into the model. The objects that take user input and transform it into the final string or messages are known as "Prompt Templates". LangChain provides several abstractions to make working with prompts easier. PromptValue​ ChatModels and LLMs take different input types. PromptValue is a class designed to be interoperable between the two. It exposes a method to be cast to a string (to work with LLMs) and another to be cast to a list of messages (to work with ChatModels). PromptTemplate​ This is an example of a prompt template. This consists of a template string. This string is then formatted with user inputs to produce a final string. MessagePromptTemplate​ This type of template consists of a template message - meaning a specific role and a PromptTemplate. This PromptTemplate is then formatted with user inputs to produce a final string that becomes the content of this message. HumanMessagePromptTemplate​ This is MessagePromptTemplate that produces a HumanMessage. AIMessagePromptTemplate​ This is MessagePromptTemplate that produces an AIMessage. SystemMessagePromptTemplate​ This is MessagePromptTemplate that produces a SystemMessage. MessagesPlaceholder​ Oftentimes inputs to prompts can be a list of messages. This is when you would use a MessagesPlaceholder. These objects are parameterized by a variable_name argument. The input with the same value as this variable_name value should be a list of messages. ChatPromptTemplate​ This is an example of a prompt template. This consists of a list of MessagePromptTemplates or MessagePlaceholders. These are then formatted with user inputs to produce a final list of messages. Output Parsers​ The output of models are either strings or a message. Oftentimes, the string or messages contains information formatted in a specific format to be used downstream (e.g. a comma separated list, or JSON blob). Output parsers are responsible for taking in the output of a model and transforming it into a more usable form. These generally work on the content of the output message, but occasionally work on values in the additional_kwargs field. StrOutputParser​ This is a simple output parser that just converts the output of a language model (LLM or ChatModel) into a string. If the model is an LLM (and therefore outputs a string) it just passes that string through. If the output is a ChatModel (and therefore outputs a message) it passes through the .content attribute of the message. OpenAI Functions Parsers​ There are a few parsers dedicated to working with OpenAI function calling. They take the output of the function_call and arguments parameters (which are inside additional_kwargs) and work with those, largely ignoring content. Agent Output Parsers​ Agents are systems that use language models to determine what steps to take. The output of a language model therefore needs to be parsed into some schema that can represent what actions (if any) are to be taken. AgentOutputParsers are responsible for taking raw LLM or ChatModel output and converting it to that schema. The logic inside these output parsers can differ depending on the model and prompting strategy being used.

https://python.langchain.com/docs/modules/model_io/llms/

## LLMs Large Language Models (LLMs) are a core component of LangChain. LangChain does not serve its own LLMs, but rather provides a standard interface for interacting with many different LLMs. To be specific, this interface is one that takes as input a string and returns a string. There are lots of LLM providers (OpenAI, Cohere, Hugging Face, etc) - the `LLM` class is designed to provide a standard interface for all of them. ## [Quick Start](https://python.langchain.com/docs/modules/model_io/llms/quick_start/)[​](#quick-start "Direct link to quick-start") Check out [this quick start](https://python.langchain.com/docs/modules/model_io/llms/quick_start/) to get an overview of working with LLMs, including all the different methods they expose ## [Integrations](https://python.langchain.com/docs/integrations/llms/)[​](#integrations "Direct link to integrations") For a full list of all LLM integrations that LangChain provides, please go to the [Integrations page](https://python.langchain.com/docs/integrations/llms/) ## How-To Guides[​](#how-to-guides "Direct link to How-To Guides") We have several how-to guides for more advanced usage of LLMs. This includes: * [How to write a custom LLM class](https://python.langchain.com/docs/modules/model_io/llms/custom_llm/) * [How to cache LLM responses](https://python.langchain.com/docs/modules/model_io/llms/llm_caching/) * [How to stream responses from an LLM](https://python.langchain.com/docs/modules/model_io/llms/streaming_llm/) * [How to track token usage in an LLM call](https://python.langchain.com/docs/modules/model_io/llms/token_usage_tracking/)

LLMs Large Language Models (LLMs) are a core component of LangChain. LangChain does not serve its own LLMs, but rather provides a standard interface for interacting with many different LLMs. To be specific, this interface is one that takes as input a string and returns a string. There are lots of LLM providers (OpenAI, Cohere, Hugging Face, etc) - the LLM class is designed to provide a standard interface for all of them. Quick Start​ Check out this quick start to get an overview of working with LLMs, including all the different methods they expose Integrations​ For a full list of all LLM integrations that LangChain provides, please go to the Integrations page How-To Guides​ We have several how-to guides for more advanced usage of LLMs. This includes: How to write a custom LLM class How to cache LLM responses How to stream responses from an LLM How to track token usage in an LLM call

https://python.langchain.com/docs/modules/model_io/llms/custom_llm/

## Custom LLM This notebook goes over how to create a custom LLM wrapper, in case you want to use your own LLM or a different wrapper than one that is supported in LangChain. Wrapping your LLM with the standard `LLM` interface allow you to use your LLM in existing LangChain programs with minimal code modifications! As an bonus, your LLM will automatically become a LangChain `Runnable` and will benefit from some optimizations out of the box, async support, the `astream_events` API, etc. ## Implementation[​](#implementation "Direct link to Implementation") There are only two required things that a custom LLM needs to implement: | Method | Description | | --- | --- | | `_call` | Takes in a string and some optional stop words, and returns a string. Used by `invoke`. | | `_llm_type` | A property that returns a string, used for logging purposes only. | Optional implementations: | Method | Description | | --- | --- | | `_identifying_params` | Used to help with identifying the model and printing the LLM; should return a dictionary. This is a **@property**. | | `_acall` | Provides an async native implementation of `_call`, used by `ainvoke`. | | `_stream` | Method to stream the output token by token. | | `_astream` | Provides an async native implementation of `_stream`; in newer LangChain versions, defaults to `_stream`. | Let’s implement a simple custom LLM that just returns the first n characters of the input. ``` from typing import Any, Dict, Iterator, List, Mapping, Optionalfrom langchain_core.callbacks.manager import CallbackManagerForLLMRunfrom langchain_core.language_models.llms import LLMfrom langchain_core.outputs import GenerationChunkclass CustomLLM(LLM): """A custom chat model that echoes the first `n` characters of the input. When contributing an implementation to LangChain, carefully document the model including the initialization parameters, include an example of how to initialize the model and include any relevant links to the underlying models documentation or API. Example: .. code-block:: python model = CustomChatModel(n=2) result = model.invoke([HumanMessage(content="hello")]) result = model.batch([[HumanMessage(content="hello")], [HumanMessage(content="world")]]) """ n: int """The number of characters from the last message of the prompt to be echoed.""" def _call( self, prompt: str, stop: Optional[List[str]] = None, run_manager: Optional[CallbackManagerForLLMRun] = None, **kwargs: Any, ) -> str: """Run the LLM on the given input. Override this method to implement the LLM logic. Args: prompt: The prompt to generate from. stop: Stop words to use when generating. Model output is cut off at the first occurrence of any of the stop substrings. If stop tokens are not supported consider raising NotImplementedError. run_manager: Callback manager for the run. **kwargs: Arbitrary additional keyword arguments. These are usually passed to the model provider API call. Returns: The model output as a string. Actual completions SHOULD NOT include the prompt. """ if stop is not None: raise ValueError("stop kwargs are not permitted.") return prompt[: self.n] def _stream( self, prompt: str, stop: Optional[List[str]] = None, run_manager: Optional[CallbackManagerForLLMRun] = None, **kwargs: Any, ) -> Iterator[GenerationChunk]: """Stream the LLM on the given prompt. This method should be overridden by subclasses that support streaming. If not implemented, the default behavior of calls to stream will be to fallback to the non-streaming version of the model and return the output as a single chunk. Args: prompt: The prompt to generate from. stop: Stop words to use when generating. Model output is cut off at the first occurrence of any of these substrings. run_manager: Callback manager for the run. **kwargs: Arbitrary additional keyword arguments. These are usually passed to the model provider API call. Returns: An iterator of GenerationChunks. """ for char in prompt[: self.n]: chunk = GenerationChunk(text=char) if run_manager: run_manager.on_llm_new_token(chunk.text, chunk=chunk) yield chunk @property def _identifying_params(self) -> Dict[str, Any]: """Return a dictionary of identifying parameters.""" return { # The model name allows users to specify custom token counting # rules in LLM monitoring applications (e.g., in LangSmith users # can provide per token pricing for their model and monitor # costs for the given LLM.) "model_name": "CustomChatModel", } @property def _llm_type(self) -> str: """Get the type of language model used by this chat model. Used for logging purposes only.""" return "custom" ``` ### Let’s test it 🧪[​](#lets-test-it "Direct link to Let’s test it 🧪") This LLM will implement the standard `Runnable` interface of LangChain which many of the LangChain abstractions support! ``` llm = CustomLLM(n=5)print(llm) ``` ``` CustomLLMParams: {'model_name': 'CustomChatModel'} ``` ``` llm.invoke("This is a foobar thing") ``` ``` await llm.ainvoke("world") ``` ``` llm.batch(["woof woof woof", "meow meow meow"]) ``` ``` await llm.abatch(["woof woof woof", "meow meow meow"]) ``` ``` async for token in llm.astream("hello"): print(token, end="|", flush=True) ``` Let’s confirm that in integrates nicely with other `LangChain` APIs. ``` from langchain_core.prompts import ChatPromptTemplate ``` ``` prompt = ChatPromptTemplate.from_messages( [("system", "you are a bot"), ("human", "{input}")]) ``` ``` llm = CustomLLM(n=7)chain = prompt | llm ``` ``` idx = 0async for event in chain.astream_events({"input": "hello there!"}, version="v1"): print(event) idx += 1 if idx > 7: # Truncate break ``` ``` {'event': 'on_chain_start', 'run_id': '05f24b4f-7ea3-4fb6-8417-3aa21633462f', 'name': 'RunnableSequence', 'tags': [], 'metadata': {}, 'data': {'input': {'input': 'hello there!'}}}{'event': 'on_prompt_start', 'name': 'ChatPromptTemplate', 'run_id': '7e996251-a926-4344-809e-c425a9846d21', 'tags': ['seq:step:1'], 'metadata': {}, 'data': {'input': {'input': 'hello there!'}}}{'event': 'on_prompt_end', 'name': 'ChatPromptTemplate', 'run_id': '7e996251-a926-4344-809e-c425a9846d21', 'tags': ['seq:step:1'], 'metadata': {}, 'data': {'input': {'input': 'hello there!'}, 'output': ChatPromptValue(messages=[SystemMessage(content='you are a bot'), HumanMessage(content='hello there!')])}}{'event': 'on_llm_start', 'name': 'CustomLLM', 'run_id': 'a8766beb-10f4-41de-8750-3ea7cf0ca7e2', 'tags': ['seq:step:2'], 'metadata': {}, 'data': {'input': {'prompts': ['System: you are a bot\nHuman: hello there!']}}}{'event': 'on_llm_stream', 'name': 'CustomLLM', 'run_id': 'a8766beb-10f4-41de-8750-3ea7cf0ca7e2', 'tags': ['seq:step:2'], 'metadata': {}, 'data': {'chunk': 'S'}}{'event': 'on_chain_stream', 'run_id': '05f24b4f-7ea3-4fb6-8417-3aa21633462f', 'tags': [], 'metadata': {}, 'name': 'RunnableSequence', 'data': {'chunk': 'S'}}{'event': 'on_llm_stream', 'name': 'CustomLLM', 'run_id': 'a8766beb-10f4-41de-8750-3ea7cf0ca7e2', 'tags': ['seq:step:2'], 'metadata': {}, 'data': {'chunk': 'y'}}{'event': 'on_chain_stream', 'run_id': '05f24b4f-7ea3-4fb6-8417-3aa21633462f', 'tags': [], 'metadata': {}, 'name': 'RunnableSequence', 'data': {'chunk': 'y'}} ``` ## Contributing[​](#contributing "Direct link to Contributing") We appreciate all chat model integration contributions. Here’s a checklist to help make sure your contribution gets added to LangChain: Documentation: * The model contains doc-strings for all initialization arguments, as these will be surfaced in the [APIReference](https://api.python.langchain.com/en/stable/langchain_api_reference.html). * The class doc-string for the model contains a link to the model API if the model is powered by a service. Tests: * ☐ Add unit or integration tests to the overridden methods. Verify that `invoke`, `ainvoke`, `batch`, `stream` work if you’ve over-ridden the corresponding code. Streaming (if you’re implementing it): * ☐ Make sure to invoke the `on_llm_new_token` callback * ☐ `on_llm_new_token` is invoked BEFORE yielding the chunk Stop Token Behavior: * ☐ Stop token should be respected * ☐ Stop token should be INCLUDED as part of the response Secret API Keys: * ☐ If your model connects to an API it will likely accept API keys as part of its initialization. Use Pydantic’s `SecretStr` type for secrets, so they don’t get accidentally printed out when folks print the model.

Custom LLM This notebook goes over how to create a custom LLM wrapper, in case you want to use your own LLM or a different wrapper than one that is supported in LangChain. Wrapping your LLM with the standard LLM interface allow you to use your LLM in existing LangChain programs with minimal code modifications! As an bonus, your LLM will automatically become a LangChain Runnable and will benefit from some optimizations out of the box, async support, the astream_events API, etc. Implementation​ There are only two required things that a custom LLM needs to implement: MethodDescription _call Takes in a string and some optional stop words, and returns a string. Used by invoke. _llm_type A property that returns a string, used for logging purposes only. Optional implementations: MethodDescription _identifying_params Used to help with identifying the model and printing the LLM; should return a dictionary. This is a @property. _acall Provides an async native implementation of _call, used by ainvoke. _stream Method to stream the output token by token. _astream Provides an async native implementation of _stream; in newer LangChain versions, defaults to _stream. Let’s implement a simple custom LLM that just returns the first n characters of the input. from typing import Any, Dict, Iterator, List, Mapping, Optional from langchain_core.callbacks.manager import CallbackManagerForLLMRun from langchain_core.language_models.llms import LLM from langchain_core.outputs import GenerationChunk class CustomLLM(LLM): """A custom chat model that echoes the first `n` characters of the input. When contributing an implementation to LangChain, carefully document the model including the initialization parameters, include an example of how to initialize the model and include any relevant links to the underlying models documentation or API. Example: .. code-block:: python model = CustomChatModel(n=2) result = model.invoke([HumanMessage(content="hello")]) result = model.batch([[HumanMessage(content="hello")], [HumanMessage(content="world")]]) """ n: int """The number of characters from the last message of the prompt to be echoed.""" def _call( self, prompt: str, stop: Optional[List[str]] = None, run_manager: Optional[CallbackManagerForLLMRun] = None, **kwargs: Any, ) -> str: """Run the LLM on the given input. Override this method to implement the LLM logic. Args: prompt: The prompt to generate from. stop: Stop words to use when generating. Model output is cut off at the first occurrence of any of the stop substrings. If stop tokens are not supported consider raising NotImplementedError. run_manager: Callback manager for the run. **kwargs: Arbitrary additional keyword arguments. These are usually passed to the model provider API call. Returns: The model output as a string. Actual completions SHOULD NOT include the prompt. """ if stop is not None: raise ValueError("stop kwargs are not permitted.") return prompt[: self.n] def _stream( self, prompt: str, stop: Optional[List[str]] = None, run_manager: Optional[CallbackManagerForLLMRun] = None, **kwargs: Any, ) -> Iterator[GenerationChunk]: """Stream the LLM on the given prompt. This method should be overridden by subclasses that support streaming. If not implemented, the default behavior of calls to stream will be to fallback to the non-streaming version of the model and return the output as a single chunk. Args: prompt: The prompt to generate from. stop: Stop words to use when generating. Model output is cut off at the first occurrence of any of these substrings. run_manager: Callback manager for the run. **kwargs: Arbitrary additional keyword arguments. These are usually passed to the model provider API call. Returns: An iterator of GenerationChunks. """ for char in prompt[: self.n]: chunk = GenerationChunk(text=char) if run_manager: run_manager.on_llm_new_token(chunk.text, chunk=chunk) yield chunk @property def _identifying_params(self) -> Dict[str, Any]: """Return a dictionary of identifying parameters.""" return { # The model name allows users to specify custom token counting # rules in LLM monitoring applications (e.g., in LangSmith users # can provide per token pricing for their model and monitor # costs for the given LLM.) "model_name": "CustomChatModel", } @property def _llm_type(self) -> str: """Get the type of language model used by this chat model. Used for logging purposes only.""" return "custom" Let’s test it 🧪​ This LLM will implement the standard Runnable interface of LangChain which many of the LangChain abstractions support! llm = CustomLLM(n=5) print(llm) CustomLLM Params: {'model_name': 'CustomChatModel'} llm.invoke("This is a foobar thing") await llm.ainvoke("world") llm.batch(["woof woof woof", "meow meow meow"]) await llm.abatch(["woof woof woof", "meow meow meow"]) async for token in llm.astream("hello"): print(token, end="|", flush=True) Let’s confirm that in integrates nicely with other LangChain APIs. from langchain_core.prompts import ChatPromptTemplate prompt = ChatPromptTemplate.from_messages( [("system", "you are a bot"), ("human", "{input}")] ) llm = CustomLLM(n=7) chain = prompt | llm idx = 0 async for event in chain.astream_events({"input": "hello there!"}, version="v1"): print(event) idx += 1 if idx > 7: # Truncate break {'event': 'on_chain_start', 'run_id': '05f24b4f-7ea3-4fb6-8417-3aa21633462f', 'name': 'RunnableSequence', 'tags': [], 'metadata': {}, 'data': {'input': {'input': 'hello there!'}}} {'event': 'on_prompt_start', 'name': 'ChatPromptTemplate', 'run_id': '7e996251-a926-4344-809e-c425a9846d21', 'tags': ['seq:step:1'], 'metadata': {}, 'data': {'input': {'input': 'hello there!'}}} {'event': 'on_prompt_end', 'name': 'ChatPromptTemplate', 'run_id': '7e996251-a926-4344-809e-c425a9846d21', 'tags': ['seq:step:1'], 'metadata': {}, 'data': {'input': {'input': 'hello there!'}, 'output': ChatPromptValue(messages=[SystemMessage(content='you are a bot'), HumanMessage(content='hello there!')])}} {'event': 'on_llm_start', 'name': 'CustomLLM', 'run_id': 'a8766beb-10f4-41de-8750-3ea7cf0ca7e2', 'tags': ['seq:step:2'], 'metadata': {}, 'data': {'input': {'prompts': ['System: you are a bot\nHuman: hello there!']}}} {'event': 'on_llm_stream', 'name': 'CustomLLM', 'run_id': 'a8766beb-10f4-41de-8750-3ea7cf0ca7e2', 'tags': ['seq:step:2'], 'metadata': {}, 'data': {'chunk': 'S'}} {'event': 'on_chain_stream', 'run_id': '05f24b4f-7ea3-4fb6-8417-3aa21633462f', 'tags': [], 'metadata': {}, 'name': 'RunnableSequence', 'data': {'chunk': 'S'}} {'event': 'on_llm_stream', 'name': 'CustomLLM', 'run_id': 'a8766beb-10f4-41de-8750-3ea7cf0ca7e2', 'tags': ['seq:step:2'], 'metadata': {}, 'data': {'chunk': 'y'}} {'event': 'on_chain_stream', 'run_id': '05f24b4f-7ea3-4fb6-8417-3aa21633462f', 'tags': [], 'metadata': {}, 'name': 'RunnableSequence', 'data': {'chunk': 'y'}} Contributing​ We appreciate all chat model integration contributions. Here’s a checklist to help make sure your contribution gets added to LangChain: Documentation: The model contains doc-strings for all initialization arguments, as these will be surfaced in the APIReference. The class doc-string for the model contains a link to the model API if the model is powered by a service. Tests: ☐ Add unit or integration tests to the overridden methods. Verify that invoke, ainvoke, batch, stream work if you’ve over-ridden the corresponding code. Streaming (if you’re implementing it): ☐ Make sure to invoke the on_llm_new_token callback ☐ on_llm_new_token is invoked BEFORE yielding the chunk Stop Token Behavior: ☐ Stop token should be respected ☐ Stop token should be INCLUDED as part of the response Secret API Keys: ☐ If your model connects to an API it will likely accept API keys as part of its initialization. Use Pydantic’s SecretStr type for secrets, so they don’t get accidentally printed out when folks print the model.

https://python.langchain.com/docs/modules/model_io/llms/llm_caching/

## Caching LangChain provides an optional caching layer for LLMs. This is useful for two reasons: It can save you money by reducing the number of API calls you make to the LLM provider, if you’re often requesting the same completion multiple times. It can speed up your application by reducing the number of API calls you make to the LLM provider. ``` from langchain.globals import set_llm_cachefrom langchain_openai import OpenAI# To make the caching really obvious, lets use a slower model.llm = OpenAI(model_name="gpt-3.5-turbo-instruct", n=2, best_of=2) ``` ``` %%timefrom langchain.cache import InMemoryCacheset_llm_cache(InMemoryCache())# The first time, it is not yet in cache, so it should take longerllm.predict("Tell me a joke") ``` ``` CPU times: user 13.7 ms, sys: 6.54 ms, total: 20.2 msWall time: 330 ms ``` ``` "\n\nWhy couldn't the bicycle stand up by itself? Because it was two-tired!" ``` ``` %%time# The second time it is, so it goes fasterllm.predict("Tell me a joke") ``` ``` CPU times: user 436 µs, sys: 921 µs, total: 1.36 msWall time: 1.36 ms ``` ``` "\n\nWhy couldn't the bicycle stand up by itself? Because it was two-tired!" ``` ## SQLite Cache[​](#sqlite-cache "Direct link to SQLite Cache") ``` # We can do the same thing with a SQLite cachefrom langchain.cache import SQLiteCacheset_llm_cache(SQLiteCache(database_path=".langchain.db")) ``` ``` %%time# The first time, it is not yet in cache, so it should take longerllm.predict("Tell me a joke") ``` ``` CPU times: user 29.3 ms, sys: 17.3 ms, total: 46.7 msWall time: 364 ms ``` ``` '\n\nWhy did the tomato turn red?\n\nBecause it saw the salad dressing!' ``` ``` %%time# The second time it is, so it goes fasterllm.predict("Tell me a joke") ``` ``` CPU times: user 4.58 ms, sys: 2.23 ms, total: 6.8 msWall time: 4.68 ms ``` ``` '\n\nWhy did the tomato turn red?\n\nBecause it saw the salad dressing!' ``` * * * #### Help us out by providing feedback on this documentation page:

Caching LangChain provides an optional caching layer for LLMs. This is useful for two reasons: It can save you money by reducing the number of API calls you make to the LLM provider, if you’re often requesting the same completion multiple times. It can speed up your application by reducing the number of API calls you make to the LLM provider. from langchain.globals import set_llm_cache from langchain_openai import OpenAI # To make the caching really obvious, lets use a slower model. llm = OpenAI(model_name="gpt-3.5-turbo-instruct", n=2, best_of=2) %%time from langchain.cache import InMemoryCache set_llm_cache(InMemoryCache()) # The first time, it is not yet in cache, so it should take longer llm.predict("Tell me a joke") CPU times: user 13.7 ms, sys: 6.54 ms, total: 20.2 ms Wall time: 330 ms "\n\nWhy couldn't the bicycle stand up by itself? Because it was two-tired!" %%time # The second time it is, so it goes faster llm.predict("Tell me a joke") CPU times: user 436 µs, sys: 921 µs, total: 1.36 ms Wall time: 1.36 ms "\n\nWhy couldn't the bicycle stand up by itself? Because it was two-tired!" SQLite Cache​ # We can do the same thing with a SQLite cache from langchain.cache import SQLiteCache set_llm_cache(SQLiteCache(database_path=".langchain.db")) %%time # The first time, it is not yet in cache, so it should take longer llm.predict("Tell me a joke") CPU times: user 29.3 ms, sys: 17.3 ms, total: 46.7 ms Wall time: 364 ms '\n\nWhy did the tomato turn red?\n\nBecause it saw the salad dressing!' %%time # The second time it is, so it goes faster llm.predict("Tell me a joke") CPU times: user 4.58 ms, sys: 2.23 ms, total: 6.8 ms Wall time: 4.68 ms '\n\nWhy did the tomato turn red?\n\nBecause it saw the salad dressing!' Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/modules/model_io/output_parsers/quick_start/

## Quickstart Language models output text. But many times you may want to get more structured information than just text back. This is where output parsers come in. Output parsers are classes that help structure language model responses. There are two main methods an output parser must implement: * “Get format instructions”: A method which returns a string containing instructions for how the output of a language model should be formatted. * “Parse”: A method which takes in a string (assumed to be the response from a language model) and parses it into some structure. And then one optional one: * “Parse with prompt”: A method which takes in a string (assumed to be the response from a language model) and a prompt (assumed to be the prompt that generated such a response) and parses it into some structure. The prompt is largely provided in the event the OutputParser wants to retry or fix the output in some way, and needs information from the prompt to do so. ## Get started[​](#get-started "Direct link to Get started") Below we go over the main type of output parser, the `PydanticOutputParser`. ``` from langchain.output_parsers import PydanticOutputParserfrom langchain_core.prompts import PromptTemplatefrom langchain_core.pydantic_v1 import BaseModel, Field, validatorfrom langchain_openai import OpenAImodel = OpenAI(model_name="gpt-3.5-turbo-instruct", temperature=0.0)# Define your desired data structure.class Joke(BaseModel): setup: str = Field(description="question to set up a joke") punchline: str = Field(description="answer to resolve the joke") # You can add custom validation logic easily with Pydantic. @validator("setup") def question_ends_with_question_mark(cls, field): if field[-1] != "?": raise ValueError("Badly formed question!") return field# Set up a parser + inject instructions into the prompt template.parser = PydanticOutputParser(pydantic_object=Joke)prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()},)# And a query intended to prompt a language model to populate the data structure.prompt_and_model = prompt | modeloutput = prompt_and_model.invoke({"query": "Tell me a joke."})parser.invoke(output) ``` ``` Joke(setup='Why did the chicken cross the road?', punchline='To get to the other side!') ``` ## LCEL[​](#lcel "Direct link to LCEL") Output parsers implement the [Runnable interface](https://python.langchain.com/docs/expression_language/interface/), the basic building block of the [LangChain Expression Language (LCEL)](https://python.langchain.com/docs/expression_language/). This means they support `invoke`, `ainvoke`, `stream`, `astream`, `batch`, `abatch`, `astream_log` calls. Output parsers accept a string or `BaseMessage` as input and can return an arbitrary type. ``` Joke(setup='Why did the chicken cross the road?', punchline='To get to the other side!') ``` Instead of manually invoking the parser, we also could’ve just added it to our `Runnable` sequence: ``` chain = prompt | model | parserchain.invoke({"query": "Tell me a joke."}) ``` ``` Joke(setup='Why did the chicken cross the road?', punchline='To get to the other side!') ``` While all parsers support the streaming interface, only certain parsers can stream through partially parsed objects, since this is highly dependent on the output type. Parsers which cannot construct partial objects will simply yield the fully parsed output. The `SimpleJsonOutputParser` for example can stream through partial outputs: ``` from langchain.output_parsers.json import SimpleJsonOutputParserjson_prompt = PromptTemplate.from_template( "Return a JSON object with an `answer` key that answers the following question: {question}")json_parser = SimpleJsonOutputParser()json_chain = json_prompt | model | json_parser ``` ``` list(json_chain.stream({"question": "Who invented the microscope?"})) ``` ``` [{}, {'answer': ''}, {'answer': 'Ant'}, {'answer': 'Anton'}, {'answer': 'Antonie'}, {'answer': 'Antonie van'}, {'answer': 'Antonie van Lee'}, {'answer': 'Antonie van Leeu'}, {'answer': 'Antonie van Leeuwen'}, {'answer': 'Antonie van Leeuwenho'}, {'answer': 'Antonie van Leeuwenhoek'}] ``` While the PydanticOutputParser cannot: ``` list(chain.stream({"query": "Tell me a joke."})) ``` ``` [Joke(setup='Why did the chicken cross the road?', punchline='To get to the other side!')] ```

Quickstart Language models output text. But many times you may want to get more structured information than just text back. This is where output parsers come in. Output parsers are classes that help structure language model responses. There are two main methods an output parser must implement: “Get format instructions”: A method which returns a string containing instructions for how the output of a language model should be formatted. “Parse”: A method which takes in a string (assumed to be the response from a language model) and parses it into some structure. And then one optional one: “Parse with prompt”: A method which takes in a string (assumed to be the response from a language model) and a prompt (assumed to be the prompt that generated such a response) and parses it into some structure. The prompt is largely provided in the event the OutputParser wants to retry or fix the output in some way, and needs information from the prompt to do so. Get started​ Below we go over the main type of output parser, the PydanticOutputParser. from langchain.output_parsers import PydanticOutputParser from langchain_core.prompts import PromptTemplate from langchain_core.pydantic_v1 import BaseModel, Field, validator from langchain_openai import OpenAI model = OpenAI(model_name="gpt-3.5-turbo-instruct", temperature=0.0) # Define your desired data structure. class Joke(BaseModel): setup: str = Field(description="question to set up a joke") punchline: str = Field(description="answer to resolve the joke") # You can add custom validation logic easily with Pydantic. @validator("setup") def question_ends_with_question_mark(cls, field): if field[-1] != "?": raise ValueError("Badly formed question!") return field # Set up a parser + inject instructions into the prompt template. parser = PydanticOutputParser(pydantic_object=Joke) prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()}, ) # And a query intended to prompt a language model to populate the data structure. prompt_and_model = prompt | model output = prompt_and_model.invoke({"query": "Tell me a joke."}) parser.invoke(output) Joke(setup='Why did the chicken cross the road?', punchline='To get to the other side!') LCEL​ Output parsers implement the Runnable interface, the basic building block of the LangChain Expression Language (LCEL). This means they support invoke, ainvoke, stream, astream, batch, abatch, astream_log calls. Output parsers accept a string or BaseMessage as input and can return an arbitrary type. Joke(setup='Why did the chicken cross the road?', punchline='To get to the other side!') Instead of manually invoking the parser, we also could’ve just added it to our Runnable sequence: chain = prompt | model | parser chain.invoke({"query": "Tell me a joke."}) Joke(setup='Why did the chicken cross the road?', punchline='To get to the other side!') While all parsers support the streaming interface, only certain parsers can stream through partially parsed objects, since this is highly dependent on the output type. Parsers which cannot construct partial objects will simply yield the fully parsed output. The SimpleJsonOutputParser for example can stream through partial outputs: from langchain.output_parsers.json import SimpleJsonOutputParser json_prompt = PromptTemplate.from_template( "Return a JSON object with an `answer` key that answers the following question: {question}" ) json_parser = SimpleJsonOutputParser() json_chain = json_prompt | model | json_parser list(json_chain.stream({"question": "Who invented the microscope?"})) [{}, {'answer': ''}, {'answer': 'Ant'}, {'answer': 'Anton'}, {'answer': 'Antonie'}, {'answer': 'Antonie van'}, {'answer': 'Antonie van Lee'}, {'answer': 'Antonie van Leeu'}, {'answer': 'Antonie van Leeuwen'}, {'answer': 'Antonie van Leeuwenho'}, {'answer': 'Antonie van Leeuwenhoek'}] While the PydanticOutputParser cannot: list(chain.stream({"query": "Tell me a joke."})) [Joke(setup='Why did the chicken cross the road?', punchline='To get to the other side!')]

https://python.langchain.com/docs/modules/model_io/output_parsers/

## Output Parsers Output parsers are responsible for taking the output of an LLM and transforming it to a more suitable format. This is very useful when you are using LLMs to generate any form of structured data. Besides having a large collection of different types of output parsers, one distinguishing benefit of LangChain OutputParsers is that many of them support streaming. ## [Quick Start](https://python.langchain.com/docs/modules/model_io/output_parsers/quick_start/)[​](#quick-start "Direct link to quick-start") See [this quick-start guide](https://python.langchain.com/docs/modules/model_io/output_parsers/quick_start/) for an introduction to output parsers and how to work with them. ## Output Parser Types[​](#output-parser-types "Direct link to Output Parser Types") LangChain has lots of different types of output parsers. This is a list of output parsers LangChain supports. The table below has various pieces of information: **Name**: The name of the output parser **Supports Streaming**: Whether the output parser supports streaming. **Has Format Instructions**: Whether the output parser has format instructions. This is generally available except when (a) the desired schema is not specified in the prompt but rather in other parameters (like OpenAI function calling), or (b) when the OutputParser wraps another OutputParser. **Calls LLM**: Whether this output parser itself calls an LLM. This is usually only done by output parsers that attempt to correct misformatted output. **Input Type**: Expected input type. Most output parsers work on both strings and messages, but some (like OpenAI Functions) need a message with specific kwargs. **Output Type**: The output type of the object returned by the parser. **Description**: Our commentary on this output parser and when to use it. | Name | Supports Streaming | Has Format Instructions | Calls LLM | Input Type | Output Type | Description | | --- | --- | --- | --- | --- | --- | --- | | [OpenAITools](https://python.langchain.com/docs/modules/model_io/output_parsers/types/openai_tools/) | | (Passes `tools` to model) | | `Message` (with `tool_choice`) | JSON object | Uses latest OpenAI function calling args `tools` and `tool_choice` to structure the return output. If you are using a model that supports function calling, this is generally the most reliable method. | | [OpenAIFunctions](https://python.langchain.com/docs/modules/model_io/output_parsers/types/openai_functions/) | ✅ | (Passes `functions` to model) | | `Message` (with `function_call`) | JSON object | Uses legacy OpenAI function calling args `functions` and `function_call` to structure the return output. | | [JSON](https://python.langchain.com/docs/modules/model_io/output_parsers/types/json/) | ✅ | ✅ | | `str` \| `Message` | JSON object | Returns a JSON object as specified. You can specify a Pydantic model and it will return JSON for that model. Probably the most reliable output parser for getting structured data that does NOT use function calling. | | [XML](https://python.langchain.com/docs/modules/model_io/output_parsers/types/xml/) | ✅ | ✅ | | `str` \| `Message` | `dict` | Returns a dictionary of tags. Use when XML output is needed. Use with models that are good at writing XML (like Anthropic's). | | [CSV](https://python.langchain.com/docs/modules/model_io/output_parsers/types/csv/) | ✅ | ✅ | | `str` \| `Message` | `List[str]` | Returns a list of comma separated values. | | [OutputFixing](https://python.langchain.com/docs/modules/model_io/output_parsers/types/output_fixing/) | | | ✅ | `str` \| `Message` | | Wraps another output parser. If that output parser errors, then this will pass the error message and the bad output to an LLM and ask it to fix the output. | | [RetryWithError](https://python.langchain.com/docs/modules/model_io/output_parsers/types/retry/) | | | ✅ | `str` \| `Message` | | Wraps another output parser. If that output parser errors, then this will pass the original inputs, the bad output, and the error message to an LLM and ask it to fix it. Compared to OutputFixingParser, this one also sends the original instructions. | | [Pydantic](https://python.langchain.com/docs/modules/model_io/output_parsers/types/pydantic/) | | ✅ | | `str` \| `Message` | `pydantic.BaseModel` | Takes a user defined Pydantic model and returns data in that format. | | [YAML](https://python.langchain.com/docs/modules/model_io/output_parsers/types/yaml/) | | ✅ | | `str` \| `Message` | `pydantic.BaseModel` | Takes a user defined Pydantic model and returns data in that format. Uses YAML to encode it. | | [PandasDataFrame](https://python.langchain.com/docs/modules/model_io/output_parsers/types/pandas_dataframe/) | | ✅ | | `str` \| `Message` | `dict` | Useful for doing operations with pandas DataFrames. | | [Enum](https://python.langchain.com/docs/modules/model_io/output_parsers/types/enum/) | | ✅ | | `str` \| `Message` | `Enum` | Parses response into one of the provided enum values. | | [Datetime](https://python.langchain.com/docs/modules/model_io/output_parsers/types/datetime/) | | ✅ | | `str` \| `Message` | `datetime.datetime` | Parses response into a datetime string. | | [Structured](https://python.langchain.com/docs/modules/model_io/output_parsers/types/structured/) | | ✅ | | `str` \| `Message` | `Dict[str, str]` | An output parser that returns structured information. It is less powerful than other output parsers since it only allows for fields to be strings. This can be useful when you are working with smaller LLMs. |

Output Parsers Output parsers are responsible for taking the output of an LLM and transforming it to a more suitable format. This is very useful when you are using LLMs to generate any form of structured data. Besides having a large collection of different types of output parsers, one distinguishing benefit of LangChain OutputParsers is that many of them support streaming. Quick Start​ See this quick-start guide for an introduction to output parsers and how to work with them. Output Parser Types​ LangChain has lots of different types of output parsers. This is a list of output parsers LangChain supports. The table below has various pieces of information: Name: The name of the output parser Supports Streaming: Whether the output parser supports streaming. Has Format Instructions: Whether the output parser has format instructions. This is generally available except when (a) the desired schema is not specified in the prompt but rather in other parameters (like OpenAI function calling), or (b) when the OutputParser wraps another OutputParser. Calls LLM: Whether this output parser itself calls an LLM. This is usually only done by output parsers that attempt to correct misformatted output. Input Type: Expected input type. Most output parsers work on both strings and messages, but some (like OpenAI Functions) need a message with specific kwargs. Output Type: The output type of the object returned by the parser. Description: Our commentary on this output parser and when to use it. NameSupports StreamingHas Format InstructionsCalls LLMInput TypeOutput TypeDescription OpenAITools (Passes tools to model) Message (with tool_choice) JSON object Uses latest OpenAI function calling args tools and tool_choice to structure the return output. If you are using a model that supports function calling, this is generally the most reliable method. OpenAIFunctions ✅ (Passes functions to model) Message (with function_call) JSON object Uses legacy OpenAI function calling args functions and function_call to structure the return output. JSON ✅ ✅ str | Message JSON object Returns a JSON object as specified. You can specify a Pydantic model and it will return JSON for that model. Probably the most reliable output parser for getting structured data that does NOT use function calling. XML ✅ ✅ str | Message dict Returns a dictionary of tags. Use when XML output is needed. Use with models that are good at writing XML (like Anthropic's). CSV ✅ ✅ str | Message List[str] Returns a list of comma separated values. OutputFixing ✅ str | Message Wraps another output parser. If that output parser errors, then this will pass the error message and the bad output to an LLM and ask it to fix the output. RetryWithError ✅ str | Message Wraps another output parser. If that output parser errors, then this will pass the original inputs, the bad output, and the error message to an LLM and ask it to fix it. Compared to OutputFixingParser, this one also sends the original instructions. Pydantic ✅ str | Message pydantic.BaseModel Takes a user defined Pydantic model and returns data in that format. YAML ✅ str | Message pydantic.BaseModel Takes a user defined Pydantic model and returns data in that format. Uses YAML to encode it. PandasDataFrame ✅ str | Message dict Useful for doing operations with pandas DataFrames. Enum ✅ str | Message Enum Parses response into one of the provided enum values. Datetime ✅ str | Message datetime.datetime Parses response into a datetime string. Structured ✅ str | Message Dict[str, str] An output parser that returns structured information. It is less powerful than other output parsers since it only allows for fields to be strings. This can be useful when you are working with smaller LLMs.

https://python.langchain.com/docs/modules/model_io/llms/streaming_llm/

All `LLM`s implement the `Runnable` interface, which comes with default implementations of all methods, ie. ainvoke, batch, abatch, stream, astream. This gives all `LLM`s basic support for streaming. Streaming support defaults to returning an Iterator (or AsyncIterator in the case of async streaming) of a single value, the final result returned by the underlying `LLM` provider. This obviously doesn’t give you token-by-token streaming, which requires native support from the `LLM` provider, but ensures your code that expects an iterator of tokens can work for any of our `LLM` integrations. ``` Verse 1:Bubbles dancing in my glassClear and crisp, it's such a blastRefreshing taste, it's like a dreamSparkling water, you make me beamChorus:Oh sparkling water, you're my delightWith every sip, you make me feel so rightYou're like a party in my mouthI can't get enough, I'm hooked no doubtVerse 2:No sugar, no calories, just pure blissYou're the perfect drink, I must confessFrom lemon to lime, so many flavors to chooseSparkling water, you never fail to amuseChorus:Oh sparkling water, you're my delightWith every sip, you make me feel so rightYou're like a party in my mouthI can't get enough, I'm hooked no doubtBridge:Some may say you're just plain waterBut to me, you're so much moreYou bring a sparkle to my dayIn every single wayChorus:Oh sparkling water, you're my delightWith every sip, you make me feel so rightYou're like a party in my mouthI can't get enough, I'm hooked no doubtOutro:So here's to you, my dear sparkling waterYou'll always be my go-to drink foreverWith your effervescence and refreshing tasteYou'll always have a special place. ```

All LLMs implement the Runnable interface, which comes with default implementations of all methods, ie. ainvoke, batch, abatch, stream, astream. This gives all LLMs basic support for streaming. Streaming support defaults to returning an Iterator (or AsyncIterator in the case of async streaming) of a single value, the final result returned by the underlying LLM provider. This obviously doesn’t give you token-by-token streaming, which requires native support from the LLM provider, but ensures your code that expects an iterator of tokens can work for any of our LLM integrations. Verse 1: Bubbles dancing in my glass Clear and crisp, it's such a blast Refreshing taste, it's like a dream Sparkling water, you make me beam Chorus: Oh sparkling water, you're my delight With every sip, you make me feel so right You're like a party in my mouth I can't get enough, I'm hooked no doubt Verse 2: No sugar, no calories, just pure bliss You're the perfect drink, I must confess From lemon to lime, so many flavors to choose Sparkling water, you never fail to amuse Chorus: Oh sparkling water, you're my delight With every sip, you make me feel so right You're like a party in my mouth I can't get enough, I'm hooked no doubt Bridge: Some may say you're just plain water But to me, you're so much more You bring a sparkle to my day In every single way Chorus: Oh sparkling water, you're my delight With every sip, you make me feel so right You're like a party in my mouth I can't get enough, I'm hooked no doubt Outro: So here's to you, my dear sparkling water You'll always be my go-to drink forever With your effervescence and refreshing taste You'll always have a special place.

https://python.langchain.com/docs/modules/model_io/output_parsers/types/csv/

## CSV parser This output parser can be used when you want to return a list of comma-separated items. ``` from langchain.output_parsers import CommaSeparatedListOutputParserfrom langchain_core.prompts import PromptTemplatefrom langchain_openai import ChatOpenAIoutput_parser = CommaSeparatedListOutputParser()format_instructions = output_parser.get_format_instructions()prompt = PromptTemplate( template="List five {subject}.\n{format_instructions}", input_variables=["subject"], partial_variables={"format_instructions": format_instructions},)model = ChatOpenAI(temperature=0)chain = prompt | model | output_parser ``` ``` chain.invoke({"subject": "ice cream flavors"}) ``` ``` ['Vanilla', 'Chocolate', 'Strawberry', 'Mint Chocolate Chip', 'Cookies and Cream'] ``` ``` for s in chain.stream({"subject": "ice cream flavors"}): print(s) ``` ``` ['Vanilla']['Chocolate']['Strawberry']['Mint Chocolate Chip']['Cookies and Cream'] ``` Find out api documentation for [CommaSeparatedListOutputParser](https://api.python.langchain.com/en/latest/output_parsers/langchain_core.output_parsers.list.CommaSeparatedListOutputParser.html#langchain_core.output_parsers.list.CommaSeparatedListOutputParser). * * * #### Help us out by providing feedback on this documentation page:

CSV parser This output parser can be used when you want to return a list of comma-separated items. from langchain.output_parsers import CommaSeparatedListOutputParser from langchain_core.prompts import PromptTemplate from langchain_openai import ChatOpenAI output_parser = CommaSeparatedListOutputParser() format_instructions = output_parser.get_format_instructions() prompt = PromptTemplate( template="List five {subject}.\n{format_instructions}", input_variables=["subject"], partial_variables={"format_instructions": format_instructions}, ) model = ChatOpenAI(temperature=0) chain = prompt | model | output_parser chain.invoke({"subject": "ice cream flavors"}) ['Vanilla', 'Chocolate', 'Strawberry', 'Mint Chocolate Chip', 'Cookies and Cream'] for s in chain.stream({"subject": "ice cream flavors"}): print(s) ['Vanilla'] ['Chocolate'] ['Strawberry'] ['Mint Chocolate Chip'] ['Cookies and Cream'] Find out api documentation for CommaSeparatedListOutputParser. Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/modules/model_io/llms/quick_start/

Large Language Models (LLMs) are a core component of LangChain. LangChain does not serve its own LLMs, but rather provides a standard interface for interacting with many different LLMs. There are lots of LLM providers (OpenAI, Cohere, Hugging Face, etc) - the `LLM` class is designed to provide a standard interface for all of them. In this walkthrough we’ll work with an OpenAI LLM wrapper, although the functionalities highlighted are generic for all LLM types. Accessing the API requires an API key, which you can get by creating an account and heading [here](https://platform.openai.com/account/api-keys). Once we have a key we’ll want to set it as an environment variable by running: If you’d prefer not to set an environment variable you can pass the key in directly via the `api_key` named parameter when initiating the OpenAI LLM class: LLMs accept **strings** as inputs, or objects which can be coerced to string prompts, including `List[BaseMessage]` and `PromptValue`. ``` '\n\n1. The Phillips Curve Theory: This suggests that there is an inverse relationship between unemployment and inflation, meaning that when unemployment is low, inflation will be higher, and when unemployment is high, inflation will be lower.\n\n2. The Monetarist Theory: This theory suggests that the relationship between unemployment and inflation is weak, and that changes in the money supply are more important in determining inflation.\n\n3. The Resource Utilization Theory: This suggests that when unemployment is low, firms are able to raise wages and prices in order to take advantage of the increased demand for their products and services. This leads to higher inflation.' ``` ``` 1. The Phillips Curve Theory: This theory states that there is an inverse relationship between unemployment and inflation. As unemployment decreases, inflation increases and vice versa.2. The Cost-Push Inflation Theory: This theory suggests that an increase in unemployment leads to a decrease in aggregate demand, which causes prices to go up due to a decrease in supply.3. The Wage-Push Inflation Theory: This theory states that when unemployment is low, wages tend to increase due to competition for labor, which causes prices to rise.4. The Monetarist Theory: This theory states that there is no direct relationship between unemployment and inflation, but rather, an increase in the money supply leads to inflation, which can be caused by an increase in unemployment. ``` ``` ['\n\n1. The Phillips Curve Theory: This theory suggests that there is an inverse relationship between unemployment and inflation, meaning that when unemployment decreases, inflation rises, and when unemployment increases, inflation decreases. This theory is based on the idea that when the economy is doing well, there is more demand for goods and services, causing prices to increase.\n\n2. The Cost-Push Theory: This theory suggests that when the cost of production increases, it leads to higher prices and lower output. This can lead to higher unemployment and eventually higher inflation.\n\n3. The Demand-Pull Theory: This theory suggests that when demand for goods and services increases, it leads to higher prices and eventually higher inflation. This can lead to higher unemployment as businesses cannot keep up with the higher demand.\n\n4. The Structural Unemployment Theory: This theory suggests that when there is a mismatch between the skills of the unemployed and the skills required in the job market, it leads to higher unemployment and eventually higher inflation.'] ``` ``` '\n\n1. Phillips Curve Theory: This theory states that there is an inverse relationship between inflation and unemployment. As unemployment decreases, inflation increases, and vice versa.\n\n2. Cost-Push Theory: This theory suggests that inflation is caused by rising costs, which can be caused by an increase in unemployment. As unemployment rises, businesses are unable to keep up with demand and have to raise prices to compensate.\n\n3. Demand-Pull Theory: This theory suggests that inflation occurs when demand exceeds supply. As unemployment increases, demand for goods and services decreases, leading to a decrease in inflation.\n\n4. Monetary Theory: This theory suggests that the money supply and inflation are related to unemployment. When the money supply increases, prices increase, leading to an increase in inflation. If unemployment is high, then the money supply increases, leading to an increase in inflation.' ``` ``` 1. Phillips Curve Theory: This theory suggests that there is an inverse relationship between unemployment and inflation, meaning that when unemployment is low, inflation rises and vice versa.2. Cost-Push Theory: This theory suggests that inflation is caused by rising costs of production, such as wages, raw materials, and energy. It states that when costs increase, firms must pass these costs onto the consumer, thus raising the price of goods and services and leading to inflation.3. Demand-Pull Theory: This theory suggests that inflation is caused by an increase in demand for goods and services, leading to a rise in prices. It suggests that when unemployment is low, people have more money to spend and this increased demand pushes up prices.4. Monetarist Theory: This theory states that inflation is caused by an increase in the money supply. It suggests that when the money supply increases, people have more money to spend, leading to higher prices. ``` ``` ['\n\n1. The Phillips Curve Theory: This theory states that there is an inverse relationship between unemployment and inflation. When unemployment is low, wages increase, leading to higher prices and overall inflation.\n\n2. The Cost-Push Theory: This theory states that inflation is caused by increases in the costs of production, such as wages, goods, and services. When the cost of production increases, the prices of goods and services must also increase, leading to inflation.\n\n3. The Demand Pull Theory: This theory states that inflation is caused by an increase in aggregate demand for goods and services. When the demand is high, prices must increase in order to meet the demand. This leads to inflation.\n\n4. The Structural Unemployment Theory: This theory states that when unemployment is high, there is an excess supply of labor. This excess supply of labor can result in lower wages, which can cause inflation as people are willing to accept lower wages for the same amount of work.'] ``` ``` RunLogPatch({'op': 'replace', 'path': '', 'value': {'final_output': None, 'id': 'baf410ad-618e-44db-93c8-809da4e3ed44', 'logs': {}, 'streamed_output': []}})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '\n'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '\n'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '1'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '.'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' The'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' Phillips'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' Curve'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ':'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' This'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' theory'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' suggests'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' that'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' there'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' is'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' an'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' inverse'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' relationship'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' between'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' unemployment and'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' inflation'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '.'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' When'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' unemployment'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' is'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' low'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ','})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' inflation'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' tends'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' to'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' be'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' high'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ','})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' and'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' when'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' unemployment'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' is'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' high'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ','})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' inflation'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' tends'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' to'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' be'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' low'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '.'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' '})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '\n'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '\n'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '2'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '.'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' The'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' NA'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'IR'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'U'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' Theory'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ':'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' This'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' theory'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' suggests'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' that there is'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' a'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' natural'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' rate'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' of'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' unemployment'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ','})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' also'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' known'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' as'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' the'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' Non'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '-'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'Ac'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'celer'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'ating'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' In'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'flation'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' Rate'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' of'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' Unemployment'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' ('})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'NA'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'IR'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'U'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ').'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' According'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' to'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' this'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' theory'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ','})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' when'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' unemployment'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' is'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' below'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' the'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' NA'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'IR'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'U'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ','})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' then'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' inflation'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' will'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' increase'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ','})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' and'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' when'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' unemployment'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' is'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' above'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' the'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' NA'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'IR'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'U'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ','})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' then'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' inflation'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' will'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' decrease'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '.'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '\n'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '\n'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '3'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '.'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' The'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' Cost'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '-'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'Push'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' In'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'flation'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' Theory'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ':'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' This'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' theory'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' suggests'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' that high unemployment'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' leads'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' to'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' higher'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' wages'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ','})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' which'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' in'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' turn'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' leads'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' to'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' higher'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' prices'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' and higher inflation'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '.'})RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ''})RunLogPatch({'op': 'replace', 'path': '/final_output', 'value': {'generations': [[{'generation_info': {'finish_reason': 'stop', 'logprobs': None}, 'text': '\n' '\n' '1. The Phillips Curve: This theory ' 'suggests that there is an inverse ' 'relationship between unemployment and ' 'inflation. When unemployment is low, ' 'inflation tends to be high, and when ' 'unemployment is high, inflation tends ' 'to be low. \n' '\n' '2. The NAIRU Theory: This theory ' 'suggests that there is a natural rate ' 'of unemployment, also known as the ' 'Non-Accelerating Inflation Rate of ' 'Unemployment (NAIRU). According to this ' 'theory, when unemployment is below the ' 'NAIRU, then inflation will increase, ' 'and when unemployment is above the ' 'NAIRU, then inflation will decrease.\n' '\n' '3. The Cost-Push Inflation Theory: This ' 'theory suggests that high unemployment ' 'leads to higher wages, which in turn ' 'leads to higher prices and higher ' 'inflation.'}]], 'llm_output': None, 'run': None}}) ``` All `LLM`s come with built-in LangSmith tracing. Just set the following environment variables: and any `LLM` invocation (whether it’s nested in a chain or not) will automatically be traced. A trace will include inputs, outputs, latency, token usage, invocation params, environment params, and more. See an example here: [https://smith.langchain.com/public/7924621a-ff58-4b1c-a2a2-035a354ef434/r](https://smith.langchain.com/public/7924621a-ff58-4b1c-a2a2-035a354ef434/r). In LangSmith you can then provide feedback for any trace, compile annotated datasets for evals, debug performance in the playground, and more.

Large Language Models (LLMs) are a core component of LangChain. LangChain does not serve its own LLMs, but rather provides a standard interface for interacting with many different LLMs. There are lots of LLM providers (OpenAI, Cohere, Hugging Face, etc) - the LLM class is designed to provide a standard interface for all of them. In this walkthrough we’ll work with an OpenAI LLM wrapper, although the functionalities highlighted are generic for all LLM types. Accessing the API requires an API key, which you can get by creating an account and heading here. Once we have a key we’ll want to set it as an environment variable by running: If you’d prefer not to set an environment variable you can pass the key in directly via the api_key named parameter when initiating the OpenAI LLM class: LLMs accept strings as inputs, or objects which can be coerced to string prompts, including List[BaseMessage] and PromptValue. '\n\n1. The Phillips Curve Theory: This suggests that there is an inverse relationship between unemployment and inflation, meaning that when unemployment is low, inflation will be higher, and when unemployment is high, inflation will be lower.\n\n2. The Monetarist Theory: This theory suggests that the relationship between unemployment and inflation is weak, and that changes in the money supply are more important in determining inflation.\n\n3. The Resource Utilization Theory: This suggests that when unemployment is low, firms are able to raise wages and prices in order to take advantage of the increased demand for their products and services. This leads to higher inflation.' 1. The Phillips Curve Theory: This theory states that there is an inverse relationship between unemployment and inflation. As unemployment decreases, inflation increases and vice versa. 2. The Cost-Push Inflation Theory: This theory suggests that an increase in unemployment leads to a decrease in aggregate demand, which causes prices to go up due to a decrease in supply. 3. The Wage-Push Inflation Theory: This theory states that when unemployment is low, wages tend to increase due to competition for labor, which causes prices to rise. 4. The Monetarist Theory: This theory states that there is no direct relationship between unemployment and inflation, but rather, an increase in the money supply leads to inflation, which can be caused by an increase in unemployment. ['\n\n1. The Phillips Curve Theory: This theory suggests that there is an inverse relationship between unemployment and inflation, meaning that when unemployment decreases, inflation rises, and when unemployment increases, inflation decreases. This theory is based on the idea that when the economy is doing well, there is more demand for goods and services, causing prices to increase.\n\n2. The Cost-Push Theory: This theory suggests that when the cost of production increases, it leads to higher prices and lower output. This can lead to higher unemployment and eventually higher inflation.\n\n3. The Demand-Pull Theory: This theory suggests that when demand for goods and services increases, it leads to higher prices and eventually higher inflation. This can lead to higher unemployment as businesses cannot keep up with the higher demand.\n\n4. The Structural Unemployment Theory: This theory suggests that when there is a mismatch between the skills of the unemployed and the skills required in the job market, it leads to higher unemployment and eventually higher inflation.'] '\n\n1. Phillips Curve Theory: This theory states that there is an inverse relationship between inflation and unemployment. As unemployment decreases, inflation increases, and vice versa.\n\n2. Cost-Push Theory: This theory suggests that inflation is caused by rising costs, which can be caused by an increase in unemployment. As unemployment rises, businesses are unable to keep up with demand and have to raise prices to compensate.\n\n3. Demand-Pull Theory: This theory suggests that inflation occurs when demand exceeds supply. As unemployment increases, demand for goods and services decreases, leading to a decrease in inflation.\n\n4. Monetary Theory: This theory suggests that the money supply and inflation are related to unemployment. When the money supply increases, prices increase, leading to an increase in inflation. If unemployment is high, then the money supply increases, leading to an increase in inflation.' 1. Phillips Curve Theory: This theory suggests that there is an inverse relationship between unemployment and inflation, meaning that when unemployment is low, inflation rises and vice versa. 2. Cost-Push Theory: This theory suggests that inflation is caused by rising costs of production, such as wages, raw materials, and energy. It states that when costs increase, firms must pass these costs onto the consumer, thus raising the price of goods and services and leading to inflation. 3. Demand-Pull Theory: This theory suggests that inflation is caused by an increase in demand for goods and services, leading to a rise in prices. It suggests that when unemployment is low, people have more money to spend and this increased demand pushes up prices. 4. Monetarist Theory: This theory states that inflation is caused by an increase in the money supply. It suggests that when the money supply increases, people have more money to spend, leading to higher prices. ['\n\n1. The Phillips Curve Theory: This theory states that there is an inverse relationship between unemployment and inflation. When unemployment is low, wages increase, leading to higher prices and overall inflation.\n\n2. The Cost-Push Theory: This theory states that inflation is caused by increases in the costs of production, such as wages, goods, and services. When the cost of production increases, the prices of goods and services must also increase, leading to inflation.\n\n3. The Demand Pull Theory: This theory states that inflation is caused by an increase in aggregate demand for goods and services. When the demand is high, prices must increase in order to meet the demand. This leads to inflation.\n\n4. The Structural Unemployment Theory: This theory states that when unemployment is high, there is an excess supply of labor. This excess supply of labor can result in lower wages, which can cause inflation as people are willing to accept lower wages for the same amount of work.'] RunLogPatch({'op': 'replace', 'path': '', 'value': {'final_output': None, 'id': 'baf410ad-618e-44db-93c8-809da4e3ed44', 'logs': {}, 'streamed_output': []}}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '\n'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '\n'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '1'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '.'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' The'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' Phillips'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' Curve'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ':'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' This'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' theory'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' suggests'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' that'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' there'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' is'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' an'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' inverse'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' relationship'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' between'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' unemployment and'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' inflation'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '.'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' When'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' unemployment'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' is'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' low'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ','}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' inflation'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' tends'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' to'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' be'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' high'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ','}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' and'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' when'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' unemployment'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' is'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' high'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ','}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' inflation'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' tends'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' to'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' be'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' low'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '.'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' '}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '\n'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '\n'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '2'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '.'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' The'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' NA'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'IR'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'U'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' Theory'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ':'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' This'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' theory'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' suggests'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' that there is'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' a'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' natural'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' rate'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' of'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' unemployment'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ','}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' also'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' known'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' as'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' the'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' Non'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '-'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'Ac'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'celer'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'ating'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' In'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'flation'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' Rate'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' of'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' Unemployment'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' ('}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'NA'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'IR'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'U'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ').'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' According'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' to'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' this'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' theory'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ','}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' when'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' unemployment'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' is'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' below'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' the'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' NA'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'IR'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'U'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ','}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' then'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' inflation'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' will'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' increase'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ','}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' and'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' when'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' unemployment'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' is'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' above'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' the'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' NA'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'IR'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'U'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ','}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' then'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' inflation'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' will'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' decrease'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '.'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '\n'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '\n'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '3'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '.'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' The'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' Cost'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '-'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'Push'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' In'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': 'flation'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' Theory'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ':'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' This'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' theory'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' suggests'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' that high unemployment'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' leads'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' to'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' higher'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' wages'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ','}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' which'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' in'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' turn'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' leads'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' to'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' higher'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' prices'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ' and higher inflation'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': '.'}) RunLogPatch({'op': 'add', 'path': '/streamed_output/-', 'value': ''}) RunLogPatch({'op': 'replace', 'path': '/final_output', 'value': {'generations': [[{'generation_info': {'finish_reason': 'stop', 'logprobs': None}, 'text': '\n' '\n' '1. The Phillips Curve: This theory ' 'suggests that there is an inverse ' 'relationship between unemployment and ' 'inflation. When unemployment is low, ' 'inflation tends to be high, and when ' 'unemployment is high, inflation tends ' 'to be low. \n' '\n' '2. The NAIRU Theory: This theory ' 'suggests that there is a natural rate ' 'of unemployment, also known as the ' 'Non-Accelerating Inflation Rate of ' 'Unemployment (NAIRU). According to this ' 'theory, when unemployment is below the ' 'NAIRU, then inflation will increase, ' 'and when unemployment is above the ' 'NAIRU, then inflation will decrease.\n' '\n' '3. The Cost-Push Inflation Theory: This ' 'theory suggests that high unemployment ' 'leads to higher wages, which in turn ' 'leads to higher prices and higher ' 'inflation.'}]], 'llm_output': None, 'run': None}}) All LLMs come with built-in LangSmith tracing. Just set the following environment variables: and any LLM invocation (whether it’s nested in a chain or not) will automatically be traced. A trace will include inputs, outputs, latency, token usage, invocation params, environment params, and more. See an example here: https://smith.langchain.com/public/7924621a-ff58-4b1c-a2a2-035a354ef434/r. In LangSmith you can then provide feedback for any trace, compile annotated datasets for evals, debug performance in the playground, and more.

https://python.langchain.com/docs/modules/model_io/output_parsers/custom/

## Custom Output Parsers In some situations you may want to implement a custom parser to structure the model output into a custom format. There are two ways to implement a custom parser: 1. Using `RunnableLambda` or `RunnableGenerator` in LCEL – we strongly recommend this for most use cases 2. By inherting from one of the base classes for out parsing – this is the hard way of doing things The difference between the two approaches are mostly superficial and are mainly in terms of which callbacks are triggered (e.g., `on_chain_start` vs. `on_parser_start`), and how a runnable lambda vs. a parser might be visualized in a tracing platform like LangSmith. ## Runnable Lambdas and Generators[​](#runnable-lambdas-and-generators "Direct link to Runnable Lambdas and Generators") The recommended way to parse is using **runnable lambdas** and **runnable generators**! Here, we will make a simple parse that inverts the case of the output from the model. For example, if the model outputs: “Meow”, the parser will produce “mEOW”. ``` from typing import Iterablefrom langchain_anthropic.chat_models import ChatAnthropicfrom langchain_core.messages import AIMessage, AIMessageChunkmodel = ChatAnthropic(model_name="claude-2.1")def parse(ai_message: AIMessage) -> str: """Parse the AI message.""" return ai_message.content.swapcase()chain = model | parsechain.invoke("hello") ``` tip LCEL automatically upgrades the function `parse` to `RunnableLambda(parse)` when composed using a `|` syntax. If you don’t like that you can manually import `RunnableLambda` and then run`parse = RunnableLambda(parse)`. Does streaming work? ``` for chunk in chain.stream("tell me about yourself in one sentence"): print(chunk, end="|", flush=True) ``` ``` i'M cLAUDE, AN ai ASSISTANT CREATED BY aNTHROPIC TO BE HELPFUL, HARMLESS, AND HONEST.| ``` No, it doesn’t because the parser aggregates the input before parsing the output. If we want to implement a streaming parser, we can have the parser accept an iterable over the input instead and yield the results as they’re available. ``` from langchain_core.runnables import RunnableGeneratordef streaming_parse(chunks: Iterable[AIMessageChunk]) -> Iterable[str]: for chunk in chunks: yield chunk.content.swapcase()streaming_parse = RunnableGenerator(streaming_parse) ``` info Please wrap the streaming parser in `RunnableGenerator` as we may stop automatically upgrading it with the `|` syntax. ``` chain = model | streaming_parsechain.invoke("hello") ``` Let’s confirm that streaming works! ``` for chunk in chain.stream("tell me about yourself in one sentence"): print(chunk, end="|", flush=True) ``` ``` i|'M| cLAUDE|,| AN| ai| ASSISTANT| CREATED| BY| aN|THROP|IC| TO| BE| HELPFUL|,| HARMLESS|,| AND| HONEST|.| ``` ## Inherting from Parsing Base Classes[​](#inherting-from-parsing-base-classes "Direct link to Inherting from Parsing Base Classes") Another approach to implement a parser is by inherting from `BaseOutputParser`, `BaseGenerationOutputParser` or another one of the base parsers depending on what you need to do. In general, we **do not** recommend this approach for most use cases as it results in more code to write without significant benefits. The simplest kind of output parser extends the `BaseOutputParser` class and must implement the following methods: * `parse`: takes the string output from the model and parses it * (optional) `_type`: identifies the name of the parser. When the output from the chat model or LLM is malformed, the can throw an `OutputParserException` to indicate that parsing fails because of bad input. Using this exception allows code that utilizes the parser to handle the exceptions in a consistent manner. :::{.callout-tip} Parsers are Runnables! 🏃 Because `BaseOutputParser` implements the `Runnable` interface, any custom parser you will create this way will become valid LangChain Runnables and will benefit from automatic async support, batch interface, logging support etc. ::: ### Simple Parser[​](#simple-parser "Direct link to Simple Parser") Here’s a simple parser that can parse a **string** representation of a booealn (e.g., `YES` or `NO`) and convert it into the corresponding `boolean` type. ``` from langchain_core.exceptions import OutputParserExceptionfrom langchain_core.output_parsers import BaseOutputParser# The [bool] desribes a parameterization of a generic.# It's basically indicating what the return type of parse is# in this case the return type is either True or Falseclass BooleanOutputParser(BaseOutputParser[bool]): """Custom boolean parser.""" true_val: str = "YES" false_val: str = "NO" def parse(self, text: str) -> bool: cleaned_text = text.strip().upper() if cleaned_text not in (self.true_val.upper(), self.false_val.upper()): raise OutputParserException( f"BooleanOutputParser expected output value to either be " f"{self.true_val} or {self.false_val} (case-insensitive). " f"Received {cleaned_text}." ) return cleaned_text == self.true_val.upper() @property def _type(self) -> str: return "boolean_output_parser" ``` ``` parser = BooleanOutputParser()parser.invoke("YES") ``` ``` try: parser.invoke("MEOW")except Exception as e: print(f"Triggered an exception of type: {type(e)}") ``` ``` Triggered an exception of type: <class 'langchain_core.exceptions.OutputParserException'> ``` Let’s test changing the parameterization ``` parser = BooleanOutputParser(true_val="OKAY")parser.invoke("OKAY") ``` Let’s confirm that other LCEL methods are present ``` parser.batch(["OKAY", "NO"]) ``` ``` await parser.abatch(["OKAY", "NO"]) ``` ``` from langchain_anthropic.chat_models import ChatAnthropicanthropic = ChatAnthropic(model_name="claude-2.1")anthropic.invoke("say OKAY or NO") ``` ``` AIMessage(content='OKAY') ``` Let’s test that our parser works! ``` chain = anthropic | parserchain.invoke("say OKAY or NO") ``` note The parser will work with either the output from an LLM (a string) or the output from a chat model (an `AIMessage`)! ### Parsing Raw Model Outputs[​](#parsing-raw-model-outputs "Direct link to Parsing Raw Model Outputs") Sometimes there is additional metadata on the model output that is important besides the raw text. One example of this is tool calling, where arguments intended to be passed to called functions are returned in a separate property. If you need this finer-grained control, you can instead subclass the `BaseGenerationOutputParser` class. This class requires a single method `parse_result`. This method takes raw model output (e.g., list of `Generation` or `ChatGeneration`) and returns the parsed output. Supporting both `Generation` and `ChatGeneration` allows the parser to work with both regular LLMs as well as with Chat Models. ``` from typing import Listfrom langchain_core.exceptions import OutputParserExceptionfrom langchain_core.messages import AIMessagefrom langchain_core.output_parsers import BaseGenerationOutputParserfrom langchain_core.outputs import ChatGeneration, Generationclass StrInvertCase(BaseGenerationOutputParser[str]): """An example parser that inverts the case of the characters in the message. This is an example parse shown just for demonstration purposes and to keep the example as simple as possible. """ def parse_result(self, result: List[Generation], *, partial: bool = False) -> str: """Parse a list of model Generations into a specific format. Args: result: A list of Generations to be parsed. The Generations are assumed to be different candidate outputs for a single model input. Many parsers assume that only a single generation is passed it in. We will assert for that partial: Whether to allow partial results. This is used for parsers that support streaming """ if len(result) != 1: raise NotImplementedError( "This output parser can only be used with a single generation." ) generation = result[0] if not isinstance(generation, ChatGeneration): # Say that this one only works with chat generations raise OutputParserException( "This output parser can only be used with a chat generation." ) return generation.message.content.swapcase()chain = anthropic | StrInvertCase() ``` Let’s the new parser! It should be inverting the output from the model. ``` chain.invoke("Tell me a short sentence about yourself") ``` ``` 'hELLO! mY NAME IS cLAUDE.' ```

Custom Output Parsers In some situations you may want to implement a custom parser to structure the model output into a custom format. There are two ways to implement a custom parser: Using RunnableLambda or RunnableGenerator in LCEL – we strongly recommend this for most use cases By inherting from one of the base classes for out parsing – this is the hard way of doing things The difference between the two approaches are mostly superficial and are mainly in terms of which callbacks are triggered (e.g., on_chain_start vs. on_parser_start), and how a runnable lambda vs. a parser might be visualized in a tracing platform like LangSmith. Runnable Lambdas and Generators​ The recommended way to parse is using runnable lambdas and runnable generators! Here, we will make a simple parse that inverts the case of the output from the model. For example, if the model outputs: “Meow”, the parser will produce “mEOW”. from typing import Iterable from langchain_anthropic.chat_models import ChatAnthropic from langchain_core.messages import AIMessage, AIMessageChunk model = ChatAnthropic(model_name="claude-2.1") def parse(ai_message: AIMessage) -> str: """Parse the AI message.""" return ai_message.content.swapcase() chain = model | parse chain.invoke("hello") tip LCEL automatically upgrades the function parse to RunnableLambda(parse) when composed using a | syntax. If you don’t like that you can manually import RunnableLambda and then runparse = RunnableLambda(parse). Does streaming work? for chunk in chain.stream("tell me about yourself in one sentence"): print(chunk, end="|", flush=True) i'M cLAUDE, AN ai ASSISTANT CREATED BY aNTHROPIC TO BE HELPFUL, HARMLESS, AND HONEST.| No, it doesn’t because the parser aggregates the input before parsing the output. If we want to implement a streaming parser, we can have the parser accept an iterable over the input instead and yield the results as they’re available. from langchain_core.runnables import RunnableGenerator def streaming_parse(chunks: Iterable[AIMessageChunk]) -> Iterable[str]: for chunk in chunks: yield chunk.content.swapcase() streaming_parse = RunnableGenerator(streaming_parse) info Please wrap the streaming parser in RunnableGenerator as we may stop automatically upgrading it with the | syntax. chain = model | streaming_parse chain.invoke("hello") Let’s confirm that streaming works! for chunk in chain.stream("tell me about yourself in one sentence"): print(chunk, end="|", flush=True) i|'M| cLAUDE|,| AN| ai| ASSISTANT| CREATED| BY| aN|THROP|IC| TO| BE| HELPFUL|,| HARMLESS|,| AND| HONEST|.| Inherting from Parsing Base Classes​ Another approach to implement a parser is by inherting from BaseOutputParser, BaseGenerationOutputParser or another one of the base parsers depending on what you need to do. In general, we do not recommend this approach for most use cases as it results in more code to write without significant benefits. The simplest kind of output parser extends the BaseOutputParser class and must implement the following methods: parse: takes the string output from the model and parses it (optional) _type: identifies the name of the parser. When the output from the chat model or LLM is malformed, the can throw an OutputParserException to indicate that parsing fails because of bad input. Using this exception allows code that utilizes the parser to handle the exceptions in a consistent manner. :::{.callout-tip} Parsers are Runnables! 🏃 Because BaseOutputParser implements the Runnable interface, any custom parser you will create this way will become valid LangChain Runnables and will benefit from automatic async support, batch interface, logging support etc. ::: Simple Parser​ Here’s a simple parser that can parse a string representation of a booealn (e.g., YES or NO) and convert it into the corresponding boolean type. from langchain_core.exceptions import OutputParserException from langchain_core.output_parsers import BaseOutputParser # The [bool] desribes a parameterization of a generic. # It's basically indicating what the return type of parse is # in this case the return type is either True or False class BooleanOutputParser(BaseOutputParser[bool]): """Custom boolean parser.""" true_val: str = "YES" false_val: str = "NO" def parse(self, text: str) -> bool: cleaned_text = text.strip().upper() if cleaned_text not in (self.true_val.upper(), self.false_val.upper()): raise OutputParserException( f"BooleanOutputParser expected output value to either be " f"{self.true_val} or {self.false_val} (case-insensitive). " f"Received {cleaned_text}." ) return cleaned_text == self.true_val.upper() @property def _type(self) -> str: return "boolean_output_parser" parser = BooleanOutputParser() parser.invoke("YES") try: parser.invoke("MEOW") except Exception as e: print(f"Triggered an exception of type: {type(e)}") Triggered an exception of type: <class 'langchain_core.exceptions.OutputParserException'> Let’s test changing the parameterization parser = BooleanOutputParser(true_val="OKAY") parser.invoke("OKAY") Let’s confirm that other LCEL methods are present parser.batch(["OKAY", "NO"]) await parser.abatch(["OKAY", "NO"]) from langchain_anthropic.chat_models import ChatAnthropic anthropic = ChatAnthropic(model_name="claude-2.1") anthropic.invoke("say OKAY or NO") AIMessage(content='OKAY') Let’s test that our parser works! chain = anthropic | parser chain.invoke("say OKAY or NO") note The parser will work with either the output from an LLM (a string) or the output from a chat model (an AIMessage)! Parsing Raw Model Outputs​ Sometimes there is additional metadata on the model output that is important besides the raw text. One example of this is tool calling, where arguments intended to be passed to called functions are returned in a separate property. If you need this finer-grained control, you can instead subclass the BaseGenerationOutputParser class. This class requires a single method parse_result. This method takes raw model output (e.g., list of Generation or ChatGeneration) and returns the parsed output. Supporting both Generation and ChatGeneration allows the parser to work with both regular LLMs as well as with Chat Models. from typing import List from langchain_core.exceptions import OutputParserException from langchain_core.messages import AIMessage from langchain_core.output_parsers import BaseGenerationOutputParser from langchain_core.outputs import ChatGeneration, Generation class StrInvertCase(BaseGenerationOutputParser[str]): """An example parser that inverts the case of the characters in the message. This is an example parse shown just for demonstration purposes and to keep the example as simple as possible. """ def parse_result(self, result: List[Generation], *, partial: bool = False) -> str: """Parse a list of model Generations into a specific format. Args: result: A list of Generations to be parsed. The Generations are assumed to be different candidate outputs for a single model input. Many parsers assume that only a single generation is passed it in. We will assert for that partial: Whether to allow partial results. This is used for parsers that support streaming """ if len(result) != 1: raise NotImplementedError( "This output parser can only be used with a single generation." ) generation = result[0] if not isinstance(generation, ChatGeneration): # Say that this one only works with chat generations raise OutputParserException( "This output parser can only be used with a chat generation." ) return generation.message.content.swapcase() chain = anthropic | StrInvertCase() Let’s the new parser! It should be inverting the output from the model. chain.invoke("Tell me a short sentence about yourself") 'hELLO! mY NAME IS cLAUDE.'

https://python.langchain.com/docs/modules/model_io/output_parsers/types/datetime/

## Datetime parser This OutputParser can be used to parse LLM output into datetime format. ``` from langchain.output_parsers import DatetimeOutputParserfrom langchain_core.prompts import PromptTemplatefrom langchain_openai import OpenAI ``` ``` output_parser = DatetimeOutputParser()template = """Answer the users question:{question}{format_instructions}"""prompt = PromptTemplate.from_template( template, partial_variables={"format_instructions": output_parser.get_format_instructions()},) ``` ``` PromptTemplate(input_variables=['question'], partial_variables={'format_instructions': "Write a datetime string that matches the following pattern: '%Y-%m-%dT%H:%M:%S.%fZ'.\n\nExamples: 0668-08-09T12:56:32.732651Z, 1213-06-23T21:01:36.868629Z, 0713-07-06T18:19:02.257488Z\n\nReturn ONLY this string, no other words!"}, template='Answer the users question:\n\n{question}\n\n{format_instructions}') ``` ``` chain = prompt | OpenAI() | output_parser ``` ``` output = chain.invoke({"question": "when was bitcoin founded?"}) ``` Find out api documentation for [DatetimeOutputParser](https://api.python.langchain.com/en/latest/output_parsers/langchain.output_parsers.datetime.DatetimeOutputParser.html#langchain.output_parsers.datetime.DatetimeOutputParser). * * * #### Help us out by providing feedback on this documentation page:

Datetime parser This OutputParser can be used to parse LLM output into datetime format. from langchain.output_parsers import DatetimeOutputParser from langchain_core.prompts import PromptTemplate from langchain_openai import OpenAI output_parser = DatetimeOutputParser() template = """Answer the users question: {question} {format_instructions}""" prompt = PromptTemplate.from_template( template, partial_variables={"format_instructions": output_parser.get_format_instructions()}, ) PromptTemplate(input_variables=['question'], partial_variables={'format_instructions': "Write a datetime string that matches the following pattern: '%Y-%m-%dT%H:%M:%S.%fZ'.\n\nExamples: 0668-08-09T12:56:32.732651Z, 1213-06-23T21:01:36.868629Z, 0713-07-06T18:19:02.257488Z\n\nReturn ONLY this string, no other words!"}, template='Answer the users question:\n\n{question}\n\n{format_instructions}') chain = prompt | OpenAI() | output_parser output = chain.invoke({"question": "when was bitcoin founded?"}) Find out api documentation for DatetimeOutputParser. Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/modules/model_io/output_parsers/types/enum/

## Enum parser This notebook shows how to use an Enum output parser. ``` from langchain.output_parsers.enum import EnumOutputParser ``` ``` from enum import Enumclass Colors(Enum): RED = "red" GREEN = "green" BLUE = "blue" ``` ``` parser = EnumOutputParser(enum=Colors) ``` ``` from langchain_core.prompts import PromptTemplatefrom langchain_openai import ChatOpenAIprompt = PromptTemplate.from_template( """What color eyes does this person have?> Person: {person}Instructions: {instructions}""").partial(instructions=parser.get_format_instructions())chain = prompt | ChatOpenAI() | parser ``` ``` chain.invoke({"person": "Frank Sinatra"}) ``` Find out api documentation for [EnumOutputParser](https://api.python.langchain.com/en/latest/output_parsers/langchain.output_parsers.enum.EnumOutputParser.html#langchain.output_parsers.enum.EnumOutputParser). * * * #### Help us out by providing feedback on this documentation page:

Enum parser This notebook shows how to use an Enum output parser. from langchain.output_parsers.enum import EnumOutputParser from enum import Enum class Colors(Enum): RED = "red" GREEN = "green" BLUE = "blue" parser = EnumOutputParser(enum=Colors) from langchain_core.prompts import PromptTemplate from langchain_openai import ChatOpenAI prompt = PromptTemplate.from_template( """What color eyes does this person have? > Person: {person} Instructions: {instructions}""" ).partial(instructions=parser.get_format_instructions()) chain = prompt | ChatOpenAI() | parser chain.invoke({"person": "Frank Sinatra"}) Find out api documentation for EnumOutputParser. Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/modules/model_io/llms/token_usage_tracking/

## Tracking token usage This notebook goes over how to track your token usage for specific calls. It is currently only implemented for the OpenAI API. Let’s first look at an extremely simple example of tracking token usage for a single LLM call. ``` from langchain_community.callbacks import get_openai_callbackfrom langchain_openai import OpenAI ``` ``` llm = OpenAI(model_name="gpt-3.5-turbo-instruct", n=2, best_of=2) ``` ``` with get_openai_callback() as cb: result = llm.invoke("Tell me a joke") print(cb) ``` ``` Tokens Used: 37 Prompt Tokens: 4 Completion Tokens: 33Successful Requests: 1Total Cost (USD): $7.2e-05 ``` Anything inside the context manager will get tracked. Here’s an example of using it to track multiple calls in sequence. ``` with get_openai_callback() as cb: result = llm.invoke("Tell me a joke") result2 = llm.invoke("Tell me a joke") print(cb.total_tokens) ``` If a chain or agent with multiple steps in it is used, it will track all those steps. ``` from langchain.agents import AgentType, initialize_agent, load_toolsfrom langchain_openai import OpenAIllm = OpenAI(temperature=0)tools = load_tools(["serpapi", "llm-math"], llm=llm)agent = initialize_agent( tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True) ``` ``` with get_openai_callback() as cb: response = agent.run( "Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?" ) print(f"Total Tokens: {cb.total_tokens}") print(f"Prompt Tokens: {cb.prompt_tokens}") print(f"Completion Tokens: {cb.completion_tokens}") print(f"Total Cost (USD): ${cb.total_cost}") ``` ``` > Entering new AgentExecutor chain... I need to find out who Olivia Wilde's boyfriend is and then calculate his age raised to the 0.23 power.Action: SearchAction Input: "Olivia Wilde boyfriend"Observation: ["Olivia Wilde and Harry Styles took fans by surprise with their whirlwind romance, which began when they met on the set of Don't Worry Darling.", 'Olivia Wilde started dating Harry Styles after ending her years-long engagement to Jason Sudeikis — see their relationship timeline.', 'Olivia Wilde and Harry Styles were spotted early on in their relationship walking around London. (. Image ...', "Looks like Olivia Wilde and Jason Sudeikis are starting 2023 on good terms. Amid their highly publicized custody battle – and the actress' ...", 'The two started dating after Wilde split up with actor Jason Sudeikisin 2020. However, their relationship came to an end last November.', "Olivia Wilde and Harry Styles started dating during the filming of Don't Worry Darling. While the movie got a lot of backlash because of the ...", "Here's what we know so far about Harry Styles and Olivia Wilde's relationship.", 'Olivia and the Grammy winner kept their romance out of the spotlight as their relationship began just two months after her split from ex-fiancé ...', "Harry Styles and Olivia Wilde first met on the set of Don't Worry Darling and stepped out as a couple in January 2021. Relive all their biggest relationship ..."]Thought: Harry Styles is Olivia Wilde's boyfriend.Action: SearchAction Input: "Harry Styles age"Observation: 29 yearsThought: I need to calculate 29 raised to the 0.23 power.Action: CalculatorAction Input: 29^0.23Observation: Answer: 2.169459462491557Thought: I now know the final answer.Final Answer: Harry Styles is Olivia Wilde's boyfriend and his current age raised to the 0.23 power is 2.169459462491557.> Finished chain.Total Tokens: 2205Prompt Tokens: 2053Completion Tokens: 152Total Cost (USD): $0.0441 ```

Tracking token usage This notebook goes over how to track your token usage for specific calls. It is currently only implemented for the OpenAI API. Let’s first look at an extremely simple example of tracking token usage for a single LLM call. from langchain_community.callbacks import get_openai_callback from langchain_openai import OpenAI llm = OpenAI(model_name="gpt-3.5-turbo-instruct", n=2, best_of=2) with get_openai_callback() as cb: result = llm.invoke("Tell me a joke") print(cb) Tokens Used: 37 Prompt Tokens: 4 Completion Tokens: 33 Successful Requests: 1 Total Cost (USD): $7.2e-05 Anything inside the context manager will get tracked. Here’s an example of using it to track multiple calls in sequence. with get_openai_callback() as cb: result = llm.invoke("Tell me a joke") result2 = llm.invoke("Tell me a joke") print(cb.total_tokens) If a chain or agent with multiple steps in it is used, it will track all those steps. from langchain.agents import AgentType, initialize_agent, load_tools from langchain_openai import OpenAI llm = OpenAI(temperature=0) tools = load_tools(["serpapi", "llm-math"], llm=llm) agent = initialize_agent( tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True ) with get_openai_callback() as cb: response = agent.run( "Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?" ) print(f"Total Tokens: {cb.total_tokens}") print(f"Prompt Tokens: {cb.prompt_tokens}") print(f"Completion Tokens: {cb.completion_tokens}") print(f"Total Cost (USD): ${cb.total_cost}") > Entering new AgentExecutor chain... I need to find out who Olivia Wilde's boyfriend is and then calculate his age raised to the 0.23 power. Action: Search Action Input: "Olivia Wilde boyfriend" Observation: ["Olivia Wilde and Harry Styles took fans by surprise with their whirlwind romance, which began when they met on the set of Don't Worry Darling.", 'Olivia Wilde started dating Harry Styles after ending her years-long engagement to Jason Sudeikis — see their relationship timeline.', 'Olivia Wilde and Harry Styles were spotted early on in their relationship walking around London. (. Image ...', "Looks like Olivia Wilde and Jason Sudeikis are starting 2023 on good terms. Amid their highly publicized custody battle – and the actress' ...", 'The two started dating after Wilde split up with actor Jason Sudeikisin 2020. However, their relationship came to an end last November.', "Olivia Wilde and Harry Styles started dating during the filming of Don't Worry Darling. While the movie got a lot of backlash because of the ...", "Here's what we know so far about Harry Styles and Olivia Wilde's relationship.", 'Olivia and the Grammy winner kept their romance out of the spotlight as their relationship began just two months after her split from ex-fiancé ...', "Harry Styles and Olivia Wilde first met on the set of Don't Worry Darling and stepped out as a couple in January 2021. Relive all their biggest relationship ..."] Thought: Harry Styles is Olivia Wilde's boyfriend. Action: Search Action Input: "Harry Styles age" Observation: 29 years Thought: I need to calculate 29 raised to the 0.23 power. Action: Calculator Action Input: 29^0.23 Observation: Answer: 2.169459462491557 Thought: I now know the final answer. Final Answer: Harry Styles is Olivia Wilde's boyfriend and his current age raised to the 0.23 power is 2.169459462491557. > Finished chain. Total Tokens: 2205 Prompt Tokens: 2053 Completion Tokens: 152 Total Cost (USD): $0.0441

https://python.langchain.com/docs/modules/model_io/output_parsers/types/output_fixing/

## Output-fixing parser This output parser wraps another output parser, and in the event that the first one fails it calls out to another LLM to fix any errors. But we can do other things besides throw errors. Specifically, we can pass the misformatted output, along with the formatted instructions, to the model and ask it to fix it. For this example, we’ll use the above Pydantic output parser. Here’s what happens if we pass it a result that does not comply with the schema: ``` from typing import Listfrom langchain.output_parsers import PydanticOutputParserfrom langchain_core.pydantic_v1 import BaseModel, Fieldfrom langchain_openai import ChatOpenAI ``` ``` class Actor(BaseModel): name: str = Field(description="name of an actor") film_names: List[str] = Field(description="list of names of films they starred in")actor_query = "Generate the filmography for a random actor."parser = PydanticOutputParser(pydantic_object=Actor) ``` ``` misformatted = "{'name': 'Tom Hanks', 'film_names': ['Forrest Gump']}" ``` ``` parser.parse(misformatted) ``` ``` OutputParserException: Failed to parse Actor from completion {'name': 'Tom Hanks', 'film_names': ['Forrest Gump']}. Got: Expecting property name enclosed in double quotes: line 1 column 2 (char 1) ``` Now we can construct and use a `OutputFixingParser`. This output parser takes as an argument another output parser but also an LLM with which to try to correct any formatting mistakes. ``` from langchain.output_parsers import OutputFixingParsernew_parser = OutputFixingParser.from_llm(parser=parser, llm=ChatOpenAI()) ``` ``` new_parser.parse(misformatted) ``` ``` Actor(name='Tom Hanks', film_names=['Forrest Gump']) ``` Find out api documentation for [OutputFixingParser](https://api.python.langchain.com/en/latest/output_parsers/langchain.output_parsers.fix.OutputFixingParser.html#langchain.output_parsers.fix.OutputFixingParser).

Output-fixing parser This output parser wraps another output parser, and in the event that the first one fails it calls out to another LLM to fix any errors. But we can do other things besides throw errors. Specifically, we can pass the misformatted output, along with the formatted instructions, to the model and ask it to fix it. For this example, we’ll use the above Pydantic output parser. Here’s what happens if we pass it a result that does not comply with the schema: from typing import List from langchain.output_parsers import PydanticOutputParser from langchain_core.pydantic_v1 import BaseModel, Field from langchain_openai import ChatOpenAI class Actor(BaseModel): name: str = Field(description="name of an actor") film_names: List[str] = Field(description="list of names of films they starred in") actor_query = "Generate the filmography for a random actor." parser = PydanticOutputParser(pydantic_object=Actor) misformatted = "{'name': 'Tom Hanks', 'film_names': ['Forrest Gump']}" parser.parse(misformatted) OutputParserException: Failed to parse Actor from completion {'name': 'Tom Hanks', 'film_names': ['Forrest Gump']}. Got: Expecting property name enclosed in double quotes: line 1 column 2 (char 1) Now we can construct and use a OutputFixingParser. This output parser takes as an argument another output parser but also an LLM with which to try to correct any formatting mistakes. from langchain.output_parsers import OutputFixingParser new_parser = OutputFixingParser.from_llm(parser=parser, llm=ChatOpenAI()) new_parser.parse(misformatted) Actor(name='Tom Hanks', film_names=['Forrest Gump']) Find out api documentation for OutputFixingParser.

https://python.langchain.com/docs/modules/model_io/output_parsers/types/openai_functions/

These output parsers use OpenAI function calling to structure its outputs. This means they are only usable with models that support function calling. There are a few different variants: ``` {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'} ``` ``` {}{'setup': ''}{'setup': 'Why'}{'setup': 'Why don'}{'setup': "Why don't"}{'setup': "Why don't scientists"}{'setup': "Why don't scientists trust"}{'setup': "Why don't scientists trust atoms"}{'setup': "Why don't scientists trust atoms?", 'punchline': ''}{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because'}{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they'}{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make'}{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up'}{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything'}{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'} ``` This merely extracts a single key from the returned response. This is useful for when you want to return a list of things. ``` [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': 'Because he was outstanding in his field!'}] ``` ``` [][{}][{'setup': ''}][{'setup': 'Why'}][{'setup': 'Why don'}][{'setup': "Why don't"}][{'setup': "Why don't scientists"}][{'setup': "Why don't scientists trust"}][{'setup': "Why don't scientists trust atoms"}][{'setup': "Why don't scientists trust atoms?", 'punchline': ''}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': ''}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scare'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': ''}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': 'Because'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': 'Because he'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': 'Because he was'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': 'Because he was outstanding'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': 'Because he was outstanding in'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': 'Because he was outstanding in his'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': 'Because he was outstanding in his field'}][{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': 'Because he was outstanding in his field!'}] ``` This builds on top of `JsonOutputFunctionsParser` but passes the results to a Pydantic Model. This allows for further validation should you choose. ``` Joke(setup="Why don't scientists trust atoms?", punchline='Because they make up everything!') ```

These output parsers use OpenAI function calling to structure its outputs. This means they are only usable with models that support function calling. There are a few different variants: {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'} {} {'setup': ''} {'setup': 'Why'} {'setup': 'Why don'} {'setup': "Why don't"} {'setup': "Why don't scientists"} {'setup': "Why don't scientists trust"} {'setup': "Why don't scientists trust atoms"} {'setup': "Why don't scientists trust atoms?", 'punchline': ''} {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because'} {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they'} {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make'} {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up'} {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything'} {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'} This merely extracts a single key from the returned response. This is useful for when you want to return a list of things. [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': 'Because he was outstanding in his field!'}] [] [{}] [{'setup': ''}] [{'setup': 'Why'}] [{'setup': 'Why don'}] [{'setup': "Why don't"}] [{'setup': "Why don't scientists"}] [{'setup': "Why don't scientists trust"}] [{'setup': "Why don't scientists trust atoms"}] [{'setup': "Why don't scientists trust atoms?", 'punchline': ''}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': ''}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scare'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': ''}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': 'Because'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': 'Because he'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': 'Because he was'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': 'Because he was outstanding'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': 'Because he was outstanding in'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': 'Because he was outstanding in his'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': 'Because he was outstanding in his field'}] [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, {'setup': 'Why did the scarecrow win an award?', 'punchline': 'Because he was outstanding in his field!'}] This builds on top of JsonOutputFunctionsParser but passes the results to a Pydantic Model. This allows for further validation should you choose. Joke(setup="Why don't scientists trust atoms?", punchline='Because they make up everything!')

https://python.langchain.com/docs/modules/model_io/output_parsers/types/json/

## JSON parser This output parser allows users to specify an arbitrary JSON schema and query LLMs for outputs that conform to that schema. Keep in mind that large language models are leaky abstractions! You’ll have to use an LLM with sufficient capacity to generate well-formed JSON. In the OpenAI family, DaVinci can do reliably but Curie’s ability already drops off dramatically. You can optionally use Pydantic to declare your data model. ``` from typing import Listfrom langchain_core.output_parsers import JsonOutputParserfrom langchain_core.prompts import PromptTemplatefrom langchain_core.pydantic_v1 import BaseModel, Fieldfrom langchain_openai import ChatOpenAI ``` ``` model = ChatOpenAI(temperature=0) ``` ``` # Define your desired data structure.class Joke(BaseModel): setup: str = Field(description="question to set up a joke") punchline: str = Field(description="answer to resolve the joke") ``` ``` # And a query intented to prompt a language model to populate the data structure.joke_query = "Tell me a joke."# Set up a parser + inject instructions into the prompt template.parser = JsonOutputParser(pydantic_object=Joke)prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()},)chain = prompt | model | parserchain.invoke({"query": joke_query}) ``` ``` {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'} ``` ## Streaming[​](#streaming "Direct link to Streaming") This output parser supports streaming. ``` for s in chain.stream({"query": joke_query}): print(s) ``` ``` {'setup': ''}{'setup': 'Why'}{'setup': 'Why don'}{'setup': "Why don't"}{'setup': "Why don't scientists"}{'setup': "Why don't scientists trust"}{'setup': "Why don't scientists trust atoms"}{'setup': "Why don't scientists trust atoms?", 'punchline': ''}{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because'}{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they'}{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make'}{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up'}{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything'}{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'} ``` ## Without Pydantic[​](#without-pydantic "Direct link to Without Pydantic") You can also use this without Pydantic. This will prompt it return JSON, but doesn’t provide specific about what the schema should be. ``` joke_query = "Tell me a joke."parser = JsonOutputParser()prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()},)chain = prompt | model | parserchain.invoke({"query": joke_query}) ``` ``` {'joke': "Why don't scientists trust atoms? Because they make up everything!"} ``` Find out api documentation for [JsonOutputParser](https://api.python.langchain.com/en/latest/output_parsers/langchain_core.output_parsers.json.JsonOutputParser.html#langchain_core.output_parsers.json.JsonOutputParser).

JSON parser This output parser allows users to specify an arbitrary JSON schema and query LLMs for outputs that conform to that schema. Keep in mind that large language models are leaky abstractions! You’ll have to use an LLM with sufficient capacity to generate well-formed JSON. In the OpenAI family, DaVinci can do reliably but Curie’s ability already drops off dramatically. You can optionally use Pydantic to declare your data model. from typing import List from langchain_core.output_parsers import JsonOutputParser from langchain_core.prompts import PromptTemplate from langchain_core.pydantic_v1 import BaseModel, Field from langchain_openai import ChatOpenAI model = ChatOpenAI(temperature=0) # Define your desired data structure. class Joke(BaseModel): setup: str = Field(description="question to set up a joke") punchline: str = Field(description="answer to resolve the joke") # And a query intented to prompt a language model to populate the data structure. joke_query = "Tell me a joke." # Set up a parser + inject instructions into the prompt template. parser = JsonOutputParser(pydantic_object=Joke) prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()}, ) chain = prompt | model | parser chain.invoke({"query": joke_query}) {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'} Streaming​ This output parser supports streaming. for s in chain.stream({"query": joke_query}): print(s) {'setup': ''} {'setup': 'Why'} {'setup': 'Why don'} {'setup': "Why don't"} {'setup': "Why don't scientists"} {'setup': "Why don't scientists trust"} {'setup': "Why don't scientists trust atoms"} {'setup': "Why don't scientists trust atoms?", 'punchline': ''} {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because'} {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they'} {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make'} {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up'} {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything'} {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'} Without Pydantic​ You can also use this without Pydantic. This will prompt it return JSON, but doesn’t provide specific about what the schema should be. joke_query = "Tell me a joke." parser = JsonOutputParser() prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()}, ) chain = prompt | model | parser chain.invoke({"query": joke_query}) {'joke': "Why don't scientists trust atoms? Because they make up everything!"} Find out api documentation for JsonOutputParser.

https://python.langchain.com/docs/modules/model_io/output_parsers/types/openai_tools/

## OpenAI Tools These output parsers extract tool calls from OpenAI’s function calling API responses. This means they are only usable with models that support function calling, and specifically the latest `tools` and `tool_choice` parameters. We recommend familiarizing yourself with [function calling](https://python.langchain.com/docs/modules/model_io/chat/function_calling/) before reading this guide. There are a few different variants of output parsers: * [JsonOutputToolsParser](https://api.python.langchain.com/en/latest/output_parsers/langchain_core.output_parsers.openai_tools.JsonOutputToolsParser.html#langchain_core.output_parsers.openai_tools.JsonOutputToolsParser): Returns the arguments of the function call as JSON * [JsonOutputKeyToolsParser](https://api.python.langchain.com/en/latest/output_parsers/langchain_core.output_parsers.openai_tools.JsonOutputKeyToolsParser.html#langchain_core.output_parsers.openai_tools.JsonOutputKeyToolsParser): Returns the value of specific key in the function call as JSON * [PydanticToolsParser](https://api.python.langchain.com/en/latest/output_parsers/langchain_core.output_parsers.openai_tools.PydanticToolsParser.html#langchain_core.output_parsers.openai_tools.PydanticToolsParser): Returns the arguments of the function call as a Pydantic Model ``` from langchain_core.prompts import ChatPromptTemplatefrom langchain_core.pydantic_v1 import BaseModel, Field, validatorfrom langchain_openai import ChatOpenAI ``` ``` class Joke(BaseModel): """Joke to tell user.""" setup: str = Field(description="question to set up a joke") punchline: str = Field(description="answer to resolve the joke") ``` ``` model = ChatOpenAI(model="gpt-3.5-turbo", temperature=0).bind_tools([Joke]) ``` ``` [{'type': 'function', 'function': {'name': 'Joke', 'description': 'Joke to tell user.', 'parameters': {'type': 'object', 'properties': {'setup': {'description': 'question to set up a joke', 'type': 'string'}, 'punchline': {'description': 'answer to resolve the joke', 'type': 'string'}}, 'required': ['setup', 'punchline']}}}] ``` ``` prompt = ChatPromptTemplate.from_messages( [("system", "You are helpful assistant"), ("user", "{input}")]) ``` ``` from langchain.output_parsers.openai_tools import JsonOutputToolsParser ``` ``` parser = JsonOutputToolsParser() ``` ``` chain = prompt | model | parser ``` ``` chain.invoke({"input": "tell me a joke"}) ``` ``` [{'type': 'Joke', 'args': {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}}] ``` To include the tool call id we can specify `return_id=True`: ``` parser = JsonOutputToolsParser(return_id=True)chain = prompt | model | parserchain.invoke({"input": "tell me a joke"}) ``` ``` [{'type': 'Joke', 'args': {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, 'id': 'call_Isuoh0RTeQzzOKGg5QlQ7UqI'}] ``` This merely extracts a single key from the returned response. This is useful for when you are passing in a single tool and just want it’s arguments. ``` from typing import Listfrom langchain.output_parsers.openai_tools import JsonOutputKeyToolsParser ``` ``` parser = JsonOutputKeyToolsParser(key_name="Joke") ``` ``` chain = prompt | model | parser ``` ``` chain.invoke({"input": "tell me a joke"}) ``` ``` [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}] ``` Certain models can return multiple tool invocations each call, so by default the output is a list. If we just want to return the first tool invocation, we can specify `first_tool_only=True` ``` parser = JsonOutputKeyToolsParser(key_name="Joke", first_tool_only=True)chain = prompt | model | parserchain.invoke({"input": "tell me a joke"}) ``` ``` {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'} ``` This builds on top of `JsonOutputToolsParser` but passes the results to a Pydantic Model. This allows for further validation should you choose. ``` from langchain.output_parsers.openai_tools import PydanticToolsParser ``` ``` class Joke(BaseModel): """Joke to tell user.""" setup: str = Field(description="question to set up a joke") punchline: str = Field(description="answer to resolve the joke") # You can add custom validation logic easily with Pydantic. @validator("setup") def question_ends_with_question_mark(cls, field): if field[-1] != "?": raise ValueError("Badly formed question!") return fieldparser = PydanticToolsParser(tools=[Joke]) ``` ``` model = ChatOpenAI(model="gpt-3.5-turbo", temperature=0).bind_tools([Joke])chain = prompt | model | parser ``` ``` chain.invoke({"input": "tell me a joke"}) ``` ``` [Joke(setup="Why don't scientists trust atoms?", punchline='Because they make up everything!')] ```

OpenAI Tools These output parsers extract tool calls from OpenAI’s function calling API responses. This means they are only usable with models that support function calling, and specifically the latest tools and tool_choice parameters. We recommend familiarizing yourself with function calling before reading this guide. There are a few different variants of output parsers: JsonOutputToolsParser: Returns the arguments of the function call as JSON JsonOutputKeyToolsParser: Returns the value of specific key in the function call as JSON PydanticToolsParser: Returns the arguments of the function call as a Pydantic Model from langchain_core.prompts import ChatPromptTemplate from langchain_core.pydantic_v1 import BaseModel, Field, validator from langchain_openai import ChatOpenAI class Joke(BaseModel): """Joke to tell user.""" setup: str = Field(description="question to set up a joke") punchline: str = Field(description="answer to resolve the joke") model = ChatOpenAI(model="gpt-3.5-turbo", temperature=0).bind_tools([Joke]) [{'type': 'function', 'function': {'name': 'Joke', 'description': 'Joke to tell user.', 'parameters': {'type': 'object', 'properties': {'setup': {'description': 'question to set up a joke', 'type': 'string'}, 'punchline': {'description': 'answer to resolve the joke', 'type': 'string'}}, 'required': ['setup', 'punchline']}}}] prompt = ChatPromptTemplate.from_messages( [("system", "You are helpful assistant"), ("user", "{input}")] ) from langchain.output_parsers.openai_tools import JsonOutputToolsParser parser = JsonOutputToolsParser() chain = prompt | model | parser chain.invoke({"input": "tell me a joke"}) [{'type': 'Joke', 'args': {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}}] To include the tool call id we can specify return_id=True: parser = JsonOutputToolsParser(return_id=True) chain = prompt | model | parser chain.invoke({"input": "tell me a joke"}) [{'type': 'Joke', 'args': {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}, 'id': 'call_Isuoh0RTeQzzOKGg5QlQ7UqI'}] This merely extracts a single key from the returned response. This is useful for when you are passing in a single tool and just want it’s arguments. from typing import List from langchain.output_parsers.openai_tools import JsonOutputKeyToolsParser parser = JsonOutputKeyToolsParser(key_name="Joke") chain = prompt | model | parser chain.invoke({"input": "tell me a joke"}) [{'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'}] Certain models can return multiple tool invocations each call, so by default the output is a list. If we just want to return the first tool invocation, we can specify first_tool_only=True parser = JsonOutputKeyToolsParser(key_name="Joke", first_tool_only=True) chain = prompt | model | parser chain.invoke({"input": "tell me a joke"}) {'setup': "Why don't scientists trust atoms?", 'punchline': 'Because they make up everything!'} This builds on top of JsonOutputToolsParser but passes the results to a Pydantic Model. This allows for further validation should you choose. from langchain.output_parsers.openai_tools import PydanticToolsParser class Joke(BaseModel): """Joke to tell user.""" setup: str = Field(description="question to set up a joke") punchline: str = Field(description="answer to resolve the joke") # You can add custom validation logic easily with Pydantic. @validator("setup") def question_ends_with_question_mark(cls, field): if field[-1] != "?": raise ValueError("Badly formed question!") return field parser = PydanticToolsParser(tools=[Joke]) model = ChatOpenAI(model="gpt-3.5-turbo", temperature=0).bind_tools([Joke]) chain = prompt | model | parser chain.invoke({"input": "tell me a joke"}) [Joke(setup="Why don't scientists trust atoms?", punchline='Because they make up everything!')]

https://python.langchain.com/docs/modules/model_io/output_parsers/types/pandas_dataframe/

## Pandas DataFrame Parser A Pandas DataFrame is a popular data structure in the Python programming language, commonly used for data manipulation and analysis. It provides a comprehensive set of tools for working with structured data, making it a versatile option for tasks such as data cleaning, transformation, and analysis. This output parser allows users to specify an arbitrary Pandas DataFrame and query LLMs for data in the form of a formatted dictionary that extracts data from the corresponding DataFrame. Keep in mind that large language models are leaky abstractions! You’ll have to use an LLM with sufficient capacity to generate a well-formed query as per the defined format instructions. Use Pandas’ DataFrame object to declare the DataFrame you wish to perform queries on. ``` import pprintfrom typing import Any, Dictimport pandas as pdfrom langchain.output_parsers import PandasDataFrameOutputParserfrom langchain_core.prompts import PromptTemplatefrom langchain_openai import ChatOpenAI ``` ``` model = ChatOpenAI(temperature=0) ``` ``` # Solely for documentation purposes.def format_parser_output(parser_output: Dict[str, Any]) -> None: for key in parser_output.keys(): parser_output[key] = parser_output[key].to_dict() return pprint.PrettyPrinter(width=4, compact=True).pprint(parser_output) ``` ``` # Define your desired Pandas DataFrame.df = pd.DataFrame( { "num_legs": [2, 4, 8, 0], "num_wings": [2, 0, 0, 0], "num_specimen_seen": [10, 2, 1, 8], })# Set up a parser + inject instructions into the prompt template.parser = PandasDataFrameOutputParser(dataframe=df) ``` ``` # Here's an example of a column operation being performed.df_query = "Retrieve the num_wings column."# Set up the prompt.prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()},)chain = prompt | model | parserparser_output = chain.invoke({"query": df_query})format_parser_output(parser_output) ``` ``` {'num_wings': {0: 2, 1: 0, 2: 0, 3: 0}} ``` ``` # Here's an example of a row operation being performed.df_query = "Retrieve the first row."# Set up the prompt.prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()},)chain = prompt | model | parserparser_output = chain.invoke({"query": df_query})format_parser_output(parser_output) ``` ``` {'0': {'num_legs': 2, 'num_specimen_seen': 10, 'num_wings': 2}} ``` ``` # Here's an example of a random Pandas DataFrame operation limiting the number of rowsdf_query = "Retrieve the average of the num_legs column from rows 1 to 3."# Set up the prompt.prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()},)chain = prompt | model | parserparser_output = chain.invoke({"query": df_query})print(parser_output) ``` ``` # Here's an example of a poorly formatted querydf_query = "Retrieve the mean of the num_fingers column."# Set up the prompt.prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()},)chain = prompt | model | parserparser_output = chain.invoke({"query": df_query}) ``` ``` OutputParserException: Invalid column: num_fingers. Please check the format instructions. ``` Find out api documentation for [PandasDataFrameOutputParser](https://api.python.langchain.com/en/latest/output_parsers/langchain.output_parsers.pandas_dataframe.PandasDataFrameOutputParser.html#langchain.output_parsers.pandas_dataframe.PandasDataFrameOutputParser).

Pandas DataFrame Parser A Pandas DataFrame is a popular data structure in the Python programming language, commonly used for data manipulation and analysis. It provides a comprehensive set of tools for working with structured data, making it a versatile option for tasks such as data cleaning, transformation, and analysis. This output parser allows users to specify an arbitrary Pandas DataFrame and query LLMs for data in the form of a formatted dictionary that extracts data from the corresponding DataFrame. Keep in mind that large language models are leaky abstractions! You’ll have to use an LLM with sufficient capacity to generate a well-formed query as per the defined format instructions. Use Pandas’ DataFrame object to declare the DataFrame you wish to perform queries on. import pprint from typing import Any, Dict import pandas as pd from langchain.output_parsers import PandasDataFrameOutputParser from langchain_core.prompts import PromptTemplate from langchain_openai import ChatOpenAI model = ChatOpenAI(temperature=0) # Solely for documentation purposes. def format_parser_output(parser_output: Dict[str, Any]) -> None: for key in parser_output.keys(): parser_output[key] = parser_output[key].to_dict() return pprint.PrettyPrinter(width=4, compact=True).pprint(parser_output) # Define your desired Pandas DataFrame. df = pd.DataFrame( { "num_legs": [2, 4, 8, 0], "num_wings": [2, 0, 0, 0], "num_specimen_seen": [10, 2, 1, 8], } ) # Set up a parser + inject instructions into the prompt template. parser = PandasDataFrameOutputParser(dataframe=df) # Here's an example of a column operation being performed. df_query = "Retrieve the num_wings column." # Set up the prompt. prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()}, ) chain = prompt | model | parser parser_output = chain.invoke({"query": df_query}) format_parser_output(parser_output) {'num_wings': {0: 2, 1: 0, 2: 0, 3: 0}} # Here's an example of a row operation being performed. df_query = "Retrieve the first row." # Set up the prompt. prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()}, ) chain = prompt | model | parser parser_output = chain.invoke({"query": df_query}) format_parser_output(parser_output) {'0': {'num_legs': 2, 'num_specimen_seen': 10, 'num_wings': 2}} # Here's an example of a random Pandas DataFrame operation limiting the number of rows df_query = "Retrieve the average of the num_legs column from rows 1 to 3." # Set up the prompt. prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()}, ) chain = prompt | model | parser parser_output = chain.invoke({"query": df_query}) print(parser_output) # Here's an example of a poorly formatted query df_query = "Retrieve the mean of the num_fingers column." # Set up the prompt. prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()}, ) chain = prompt | model | parser parser_output = chain.invoke({"query": df_query}) OutputParserException: Invalid column: num_fingers. Please check the format instructions. Find out api documentation for PandasDataFrameOutputParser.

https://python.langchain.com/docs/modules/model_io/output_parsers/types/pydantic/

## Pydantic parser This output parser allows users to specify an arbitrary Pydantic Model and query LLMs for outputs that conform to that schema. Keep in mind that large language models are leaky abstractions! You’ll have to use an LLM with sufficient capacity to generate well-formed JSON. In the OpenAI family, DaVinci can do reliably but [Curie](https://wiprotechblogs.medium.com/davinci-vs-curie-a-comparison-between-gpt-3-engines-for-extractive-summarization-b568d4633b3b)’s ability already drops off dramatically. Use Pydantic to declare your data model. Pydantic’s BaseModel is like a Python dataclass, but with actual type checking + coercion. ``` from typing import Listfrom langchain.output_parsers import PydanticOutputParserfrom langchain_core.prompts import PromptTemplatefrom langchain_core.pydantic_v1 import BaseModel, Field, validatorfrom langchain_openai import ChatOpenAI ``` ``` model = ChatOpenAI(temperature=0) ``` ``` # Define your desired data structure.class Joke(BaseModel): setup: str = Field(description="question to set up a joke") punchline: str = Field(description="answer to resolve the joke") # You can add custom validation logic easily with Pydantic. @validator("setup") def question_ends_with_question_mark(cls, field): if field[-1] != "?": raise ValueError("Badly formed question!") return field# And a query intented to prompt a language model to populate the data structure.joke_query = "Tell me a joke."# Set up a parser + inject instructions into the prompt template.parser = PydanticOutputParser(pydantic_object=Joke)prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()},)chain = prompt | model | parserchain.invoke({"query": joke_query}) ``` ``` Joke(setup="Why don't scientists trust atoms?", punchline='Because they make up everything!') ``` ``` # Here's another example, but with a compound typed field.class Actor(BaseModel): name: str = Field(description="name of an actor") film_names: List[str] = Field(description="list of names of films they starred in")actor_query = "Generate the filmography for a random actor."parser = PydanticOutputParser(pydantic_object=Actor)prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()},)chain = prompt | model | parserchain.invoke({"query": actor_query}) ``` ``` Actor(name='Tom Hanks', film_names=['Forrest Gump', 'Cast Away', 'Saving Private Ryan', 'Toy Story', 'The Green Mile']) ``` Find out api documentation for [PydanticOutputParser](https://api.python.langchain.com/en/latest/output_parsers/langchain_core.output_parsers.pydantic.PydanticOutputParser.html#langchain_core.output_parsers.pydantic.PydanticOutputParser).

Pydantic parser This output parser allows users to specify an arbitrary Pydantic Model and query LLMs for outputs that conform to that schema. Keep in mind that large language models are leaky abstractions! You’ll have to use an LLM with sufficient capacity to generate well-formed JSON. In the OpenAI family, DaVinci can do reliably but Curie’s ability already drops off dramatically. Use Pydantic to declare your data model. Pydantic’s BaseModel is like a Python dataclass, but with actual type checking + coercion. from typing import List from langchain.output_parsers import PydanticOutputParser from langchain_core.prompts import PromptTemplate from langchain_core.pydantic_v1 import BaseModel, Field, validator from langchain_openai import ChatOpenAI model = ChatOpenAI(temperature=0) # Define your desired data structure. class Joke(BaseModel): setup: str = Field(description="question to set up a joke") punchline: str = Field(description="answer to resolve the joke") # You can add custom validation logic easily with Pydantic. @validator("setup") def question_ends_with_question_mark(cls, field): if field[-1] != "?": raise ValueError("Badly formed question!") return field # And a query intented to prompt a language model to populate the data structure. joke_query = "Tell me a joke." # Set up a parser + inject instructions into the prompt template. parser = PydanticOutputParser(pydantic_object=Joke) prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()}, ) chain = prompt | model | parser chain.invoke({"query": joke_query}) Joke(setup="Why don't scientists trust atoms?", punchline='Because they make up everything!') # Here's another example, but with a compound typed field. class Actor(BaseModel): name: str = Field(description="name of an actor") film_names: List[str] = Field(description="list of names of films they starred in") actor_query = "Generate the filmography for a random actor." parser = PydanticOutputParser(pydantic_object=Actor) prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()}, ) chain = prompt | model | parser chain.invoke({"query": actor_query}) Actor(name='Tom Hanks', film_names=['Forrest Gump', 'Cast Away', 'Saving Private Ryan', 'Toy Story', 'The Green Mile']) Find out api documentation for PydanticOutputParser.

https://python.langchain.com/docs/modules/model_io/output_parsers/types/retry/

## Retry parser While in some cases it is possible to fix any parsing mistakes by only looking at the output, in other cases it isn’t. An example of this is when the output is not just in the incorrect format, but is partially complete. Consider the below example. ``` from langchain.output_parsers import ( OutputFixingParser, PydanticOutputParser,)from langchain_core.prompts import ( PromptTemplate,)from langchain_core.pydantic_v1 import BaseModel, Fieldfrom langchain_openai import ChatOpenAI, OpenAI ``` ``` template = """Based on the user question, provide an Action and Action Input for what step should be taken.{format_instructions}Question: {query}Response:"""class Action(BaseModel): action: str = Field(description="action to take") action_input: str = Field(description="input to the action")parser = PydanticOutputParser(pydantic_object=Action) ``` ``` prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()},) ``` ``` prompt_value = prompt.format_prompt(query="who is leo di caprios gf?") ``` ``` bad_response = '{"action": "search"}' ``` If we try to parse this response as is, we will get an error: ``` parser.parse(bad_response) ``` ``` OutputParserException: Failed to parse Action from completion {"action": "search"}. Got: 1 validation error for Actionaction_input field required (type=value_error.missing) ``` If we try to use the `OutputFixingParser` to fix this error, it will be confused - namely, it doesn’t know what to actually put for action input. ``` fix_parser = OutputFixingParser.from_llm(parser=parser, llm=ChatOpenAI()) ``` ``` fix_parser.parse(bad_response) ``` ``` Action(action='search', action_input='input') ``` Instead, we can use the RetryOutputParser, which passes in the prompt (as well as the original output) to try again to get a better response. ``` from langchain.output_parsers import RetryOutputParser ``` ``` retry_parser = RetryOutputParser.from_llm(parser=parser, llm=OpenAI(temperature=0)) ``` ``` retry_parser.parse_with_prompt(bad_response, prompt_value) ``` ``` Action(action='search', action_input='leo di caprio girlfriend') ``` We can also add the RetryOutputParser easily with a custom chain which transform the raw LLM/ChatModel output into a more workable format. ``` from langchain_core.runnables import RunnableLambda, RunnableParallelcompletion_chain = prompt | OpenAI(temperature=0)main_chain = RunnableParallel( completion=completion_chain, prompt_value=prompt) | RunnableLambda(lambda x: retry_parser.parse_with_prompt(**x))main_chain.invoke({"query": "who is leo di caprios gf?"}) ``` ``` Action(action='search', action_input='leo di caprio girlfriend') ``` Find out api documentation for [RetryOutputParser](https://api.python.langchain.com/en/latest/output_parsers/langchain.output_parsers.retry.RetryOutputParser.html#langchain.output_parsers.retry.RetryOutputParser).

Retry parser While in some cases it is possible to fix any parsing mistakes by only looking at the output, in other cases it isn’t. An example of this is when the output is not just in the incorrect format, but is partially complete. Consider the below example. from langchain.output_parsers import ( OutputFixingParser, PydanticOutputParser, ) from langchain_core.prompts import ( PromptTemplate, ) from langchain_core.pydantic_v1 import BaseModel, Field from langchain_openai import ChatOpenAI, OpenAI template = """Based on the user question, provide an Action and Action Input for what step should be taken. {format_instructions} Question: {query} Response:""" class Action(BaseModel): action: str = Field(description="action to take") action_input: str = Field(description="input to the action") parser = PydanticOutputParser(pydantic_object=Action) prompt = PromptTemplate( template="Answer the user query.\n{format_instructions}\n{query}\n", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()}, ) prompt_value = prompt.format_prompt(query="who is leo di caprios gf?") bad_response = '{"action": "search"}' If we try to parse this response as is, we will get an error: parser.parse(bad_response) OutputParserException: Failed to parse Action from completion {"action": "search"}. Got: 1 validation error for Action action_input field required (type=value_error.missing) If we try to use the OutputFixingParser to fix this error, it will be confused - namely, it doesn’t know what to actually put for action input. fix_parser = OutputFixingParser.from_llm(parser=parser, llm=ChatOpenAI()) fix_parser.parse(bad_response) Action(action='search', action_input='input') Instead, we can use the RetryOutputParser, which passes in the prompt (as well as the original output) to try again to get a better response. from langchain.output_parsers import RetryOutputParser retry_parser = RetryOutputParser.from_llm(parser=parser, llm=OpenAI(temperature=0)) retry_parser.parse_with_prompt(bad_response, prompt_value) Action(action='search', action_input='leo di caprio girlfriend') We can also add the RetryOutputParser easily with a custom chain which transform the raw LLM/ChatModel output into a more workable format. from langchain_core.runnables import RunnableLambda, RunnableParallel completion_chain = prompt | OpenAI(temperature=0) main_chain = RunnableParallel( completion=completion_chain, prompt_value=prompt ) | RunnableLambda(lambda x: retry_parser.parse_with_prompt(**x)) main_chain.invoke({"query": "who is leo di caprios gf?"}) Action(action='search', action_input='leo di caprio girlfriend') Find out api documentation for RetryOutputParser.

https://python.langchain.com/docs/modules/model_io/output_parsers/types/structured/

## Structured output parser This output parser can be used when you want to return multiple fields. While the Pydantic/JSON parser is more powerful, this is useful for less powerful models. ``` from langchain.output_parsers import ResponseSchema, StructuredOutputParserfrom langchain_core.prompts import PromptTemplatefrom langchain_openai import ChatOpenAI ``` ``` response_schemas = [ ResponseSchema(name="answer", description="answer to the user's question"), ResponseSchema( name="source", description="source used to answer the user's question, should be a website.", ),]output_parser = StructuredOutputParser.from_response_schemas(response_schemas) ``` We now get a string that contains instructions for how the response should be formatted, and we then insert that into our prompt. ``` format_instructions = output_parser.get_format_instructions()prompt = PromptTemplate( template="answer the users question as best as possible.\n{format_instructions}\n{question}", input_variables=["question"], partial_variables={"format_instructions": format_instructions},) ``` ``` model = ChatOpenAI(temperature=0)chain = prompt | model | output_parser ``` ``` chain.invoke({"question": "what's the capital of france?"}) ``` ``` {'answer': 'The capital of France is Paris.', 'source': 'https://en.wikipedia.org/wiki/Paris'} ``` ``` for s in chain.stream({"question": "what's the capital of france?"}): print(s) ``` ``` {'answer': 'The capital of France is Paris.', 'source': 'https://en.wikipedia.org/wiki/Paris'} ``` Find out api documentation for [StructuredOutputParser](https://api.python.langchain.com/en/latest/output_parsers/langchain.output_parsers.structured.StructuredOutputParser.html#langchain.output_parsers.structured.StructuredOutputParser). * * * #### Help us out by providing feedback on this documentation page:

Structured output parser This output parser can be used when you want to return multiple fields. While the Pydantic/JSON parser is more powerful, this is useful for less powerful models. from langchain.output_parsers import ResponseSchema, StructuredOutputParser from langchain_core.prompts import PromptTemplate from langchain_openai import ChatOpenAI response_schemas = [ ResponseSchema(name="answer", description="answer to the user's question"), ResponseSchema( name="source", description="source used to answer the user's question, should be a website.", ), ] output_parser = StructuredOutputParser.from_response_schemas(response_schemas) We now get a string that contains instructions for how the response should be formatted, and we then insert that into our prompt. format_instructions = output_parser.get_format_instructions() prompt = PromptTemplate( template="answer the users question as best as possible.\n{format_instructions}\n{question}", input_variables=["question"], partial_variables={"format_instructions": format_instructions}, ) model = ChatOpenAI(temperature=0) chain = prompt | model | output_parser chain.invoke({"question": "what's the capital of france?"}) {'answer': 'The capital of France is Paris.', 'source': 'https://en.wikipedia.org/wiki/Paris'} for s in chain.stream({"question": "what's the capital of france?"}): print(s) {'answer': 'The capital of France is Paris.', 'source': 'https://en.wikipedia.org/wiki/Paris'} Find out api documentation for StructuredOutputParser. Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/modules/model_io/output_parsers/types/xml/

## XML parser This output parser allows users to obtain results from LLM in the popular XML format. Keep in mind that large language models are leaky abstractions! You’ll have to use an LLM with sufficient capacity to generate well-formed XML. In the following example we use Claude model ([https://docs.anthropic.com/claude/docs](https://docs.anthropic.com/claude/docs)) which works really well with XML tags. ``` from langchain.output_parsers import XMLOutputParserfrom langchain_community.chat_models import ChatAnthropicfrom langchain_core.prompts import PromptTemplate ``` ``` model = ChatAnthropic(model="claude-2", max_tokens_to_sample=512, temperature=0.1) ``` Let’s start with the simple request to the model. ``` actor_query = "Generate the shortened filmography for Tom Hanks."output = model.invoke( f"""{actor_query}Please enclose the movies in <movie></movie> tags""")print(output.content) ``` ``` Here is the shortened filmography for Tom Hanks, enclosed in XML tags:<movie>Splash</movie><movie>Big</movie><movie>A League of Their Own</movie><movie>Sleepless in Seattle</movie><movie>Forrest Gump</movie><movie>Toy Story</movie><movie>Apollo 13</movie><movie>Saving Private Ryan</movie><movie>Cast Away</movie><movie>The Da Vinci Code</movie><movie>Captain Phillips</movie> ``` Now we will use the XMLOutputParser in order to get the structured output. ``` parser = XMLOutputParser()prompt = PromptTemplate( template="""{query}\n{format_instructions}""", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()},)chain = prompt | model | parseroutput = chain.invoke({"query": actor_query})print(output) ``` ``` {'filmography': [{'movie': [{'title': 'Big'}, {'year': '1988'}]}, {'movie': [{'title': 'Forrest Gump'}, {'year': '1994'}]}, {'movie': [{'title': 'Toy Story'}, {'year': '1995'}]}, {'movie': [{'title': 'Saving Private Ryan'}, {'year': '1998'}]}, {'movie': [{'title': 'Cast Away'}, {'year': '2000'}]}]} ``` Finally, let’s add some tags to tailor the output to our needs. ``` parser = XMLOutputParser(tags=["movies", "actor", "film", "name", "genre"])prompt = PromptTemplate( template="""{query}\n{format_instructions}""", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()},)chain = prompt | model | parseroutput = chain.invoke({"query": actor_query})print(output) ``` ``` {'movies': [{'actor': [{'name': 'Tom Hanks'}, {'film': [{'name': 'Forrest Gump'}, {'genre': 'Drama'}]}, {'film': [{'name': 'Cast Away'}, {'genre': 'Adventure'}]}, {'film': [{'name': 'Saving Private Ryan'}, {'genre': 'War'}]}]}]} ``` ``` for s in chain.stream({"query": actor_query}): print(s) ``` ``` {'movies': [{'actor': [{'name': 'Tom Hanks'}]}]}{'movies': [{'actor': [{'film': [{'name': 'Forrest Gump'}]}]}]}{'movies': [{'actor': [{'film': [{'genre': 'Drama'}]}]}]}{'movies': [{'actor': [{'film': [{'name': 'Cast Away'}]}]}]}{'movies': [{'actor': [{'film': [{'genre': 'Adventure'}]}]}]}{'movies': [{'actor': [{'film': [{'name': 'Saving Private Ryan'}]}]}]}{'movies': [{'actor': [{'film': [{'genre': 'War'}]}]}]} ``` Find out api documentation for [XMLOutputParser](https://api.python.langchain.com/en/latest/output_parsers/langchain_core.output_parsers.xml.XMLOutputParser.html#langchain_core.output_parsers.xml.XMLOutputParser).

XML parser This output parser allows users to obtain results from LLM in the popular XML format. Keep in mind that large language models are leaky abstractions! You’ll have to use an LLM with sufficient capacity to generate well-formed XML. In the following example we use Claude model (https://docs.anthropic.com/claude/docs) which works really well with XML tags. from langchain.output_parsers import XMLOutputParser from langchain_community.chat_models import ChatAnthropic from langchain_core.prompts import PromptTemplate model = ChatAnthropic(model="claude-2", max_tokens_to_sample=512, temperature=0.1) Let’s start with the simple request to the model. actor_query = "Generate the shortened filmography for Tom Hanks." output = model.invoke( f"""{actor_query} Please enclose the movies in <movie></movie> tags""" ) print(output.content) Here is the shortened filmography for Tom Hanks, enclosed in XML tags: <movie>Splash</movie> <movie>Big</movie> <movie>A League of Their Own</movie> <movie>Sleepless in Seattle</movie> <movie>Forrest Gump</movie> <movie>Toy Story</movie> <movie>Apollo 13</movie> <movie>Saving Private Ryan</movie> <movie>Cast Away</movie> <movie>The Da Vinci Code</movie> <movie>Captain Phillips</movie> Now we will use the XMLOutputParser in order to get the structured output. parser = XMLOutputParser() prompt = PromptTemplate( template="""{query}\n{format_instructions}""", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()}, ) chain = prompt | model | parser output = chain.invoke({"query": actor_query}) print(output) {'filmography': [{'movie': [{'title': 'Big'}, {'year': '1988'}]}, {'movie': [{'title': 'Forrest Gump'}, {'year': '1994'}]}, {'movie': [{'title': 'Toy Story'}, {'year': '1995'}]}, {'movie': [{'title': 'Saving Private Ryan'}, {'year': '1998'}]}, {'movie': [{'title': 'Cast Away'}, {'year': '2000'}]}]} Finally, let’s add some tags to tailor the output to our needs. parser = XMLOutputParser(tags=["movies", "actor", "film", "name", "genre"]) prompt = PromptTemplate( template="""{query}\n{format_instructions}""", input_variables=["query"], partial_variables={"format_instructions": parser.get_format_instructions()}, ) chain = prompt | model | parser output = chain.invoke({"query": actor_query}) print(output) {'movies': [{'actor': [{'name': 'Tom Hanks'}, {'film': [{'name': 'Forrest Gump'}, {'genre': 'Drama'}]}, {'film': [{'name': 'Cast Away'}, {'genre': 'Adventure'}]}, {'film': [{'name': 'Saving Private Ryan'}, {'genre': 'War'}]}]}]} for s in chain.stream({"query": actor_query}): print(s) {'movies': [{'actor': [{'name': 'Tom Hanks'}]}]} {'movies': [{'actor': [{'film': [{'name': 'Forrest Gump'}]}]}]} {'movies': [{'actor': [{'film': [{'genre': 'Drama'}]}]}]} {'movies': [{'actor': [{'film': [{'name': 'Cast Away'}]}]}]} {'movies': [{'actor': [{'film': [{'genre': 'Adventure'}]}]}]} {'movies': [{'actor': [{'film': [{'name': 'Saving Private Ryan'}]}]}]} {'movies': [{'actor': [{'film': [{'genre': 'War'}]}]}]} Find out api documentation for XMLOutputParser.