update

`langchain_pinecone.Pinecone` is deprecated in favor of
`PineconeVectorStore`, and is currently a subclass of
`PineconeVectorStore`.
```python
@deprecated(since="0.0.3", removal="0.2.0", alternative="PineconeVectorStore")
class Pinecone(PineconeVectorStore):
    """Deprecated. Use PineconeVectorStore instead."""

    pass
```

.github/scripts/check_diff.py

@@ -19,6 +19,7 @@ if __name__ == "__main__":
         "test": set(),
         "extended-test": set(),
     }
+    docs_edited = False
 
     if len(files) == 300:
         # max diff length is 300 files - there are likely files missing
@@ -76,6 +77,8 @@ if __name__ == "__main__":
                 "an update for this new library!"
             )
         elif any(file.startswith(p) for p in ["docs/", "templates/", "cookbook/"]):
+            if file.startswith("docs/"):
+                docs_edited = True
             dirs_to_run["lint"].add(".")
 
     outputs = {
@@ -84,6 +87,7 @@ if __name__ == "__main__":
         ),
         "dirs-to-test": list(dirs_to_run["test"] | dirs_to_run["extended-test"]),
         "dirs-to-extended-test": list(dirs_to_run["extended-test"]),
+        "docs-edited": "true" if docs_edited else "",
     }
     for key, value in outputs.items():
         json_output = json.dumps(value)

.github/workflows/_integration_test.yml

@@ -58,6 +58,7 @@ jobs:
           MISTRAL_API_KEY: ${{ secrets.MISTRAL_API_KEY }}
           TOGETHER_API_KEY: ${{ secrets.TOGETHER_API_KEY }}
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
           NVIDIA_API_KEY: ${{ secrets.NVIDIA_API_KEY }}
           GOOGLE_SEARCH_API_KEY: ${{ secrets.GOOGLE_SEARCH_API_KEY }}
           GOOGLE_CSE_ID: ${{ secrets.GOOGLE_CSE_ID }}
@@ -77,6 +78,7 @@ jobs:
           MONGODB_ATLAS_URI: ${{ secrets.MONGODB_ATLAS_URI }}
           VOYAGE_API_KEY: ${{ secrets.VOYAGE_API_KEY }}
           COHERE_API_KEY: ${{ secrets.COHERE_API_KEY }}
+          UPSTAGE_API_KEY: ${{ secrets.UPSTAGE_API_KEY }}
         run: |
           make integration_tests
 

.github/workflows/_release.yml

@@ -112,7 +112,7 @@ jobs:
           PKG_NAME: ${{ needs.build.outputs.pkg-name }}
           VERSION: ${{ needs.build.outputs.version }}
         # Here we use:
-        # - The default regular PyPI index as the *primary* index, meaning 
+        # - The default regular PyPI index as the *primary* index, meaning
         #   that it takes priority (https://pypi.org/simple)
         # - The test PyPI index as an extra index, so that any dependencies that
         #   are not found on test PyPI can be resolved and installed anyway.
@@ -215,6 +215,7 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # for airbyte
           MONGODB_ATLAS_URI: ${{ secrets.MONGODB_ATLAS_URI }}
           VOYAGE_API_KEY: ${{ secrets.VOYAGE_API_KEY }}
+          UPSTAGE_API_KEY: ${{ secrets.UPSTAGE_API_KEY }}
         run: make integration_tests
         working-directory: ${{ inputs.working-directory }}
 

.github/workflows/check_diffs.yml

@@ -36,6 +36,7 @@ jobs:
       dirs-to-lint: ${{ steps.set-matrix.outputs.dirs-to-lint }}
       dirs-to-test: ${{ steps.set-matrix.outputs.dirs-to-test }}
       dirs-to-extended-test: ${{ steps.set-matrix.outputs.dirs-to-extended-test }}
+      docs-edited: ${{ steps.set-matrix.outputs.docs-edited }}
   lint:
     name: cd ${{ matrix.working-directory }}
     needs: [ build ]
@@ -60,9 +61,9 @@ jobs:
       working-directory: ${{ matrix.working-directory }}
     secrets: inherit
 
-  test_doc_imports:
+  test-doc-imports:
     needs: [ build ]
-    if: ${{ needs.build.outputs.dirs-to-test != '[]' }}
+    if: ${{ needs.build.outputs.dirs-to-test != '[]' || needs.build.outputs.docs-edited }}
     uses: ./.github/workflows/_test_doc_imports.yml
     secrets: inherit
 
@@ -140,7 +141,7 @@ jobs:
           echo "$STATUS" | grep 'nothing to commit, working tree clean'
   ci_success:
     name: "CI Success"
-    needs: [build, lint, test, compile-integration-tests, dependencies, extended-tests]
+    needs: [build, lint, test, compile-integration-tests, dependencies, extended-tests, test-doc-imports]
     if: |
       always()
     runs-on: ubuntu-latest

.github/workflows/scheduled_test.yml

@@ -10,19 +10,21 @@ env:
 
 jobs:
   build:
-    defaults:
-      run:
-        working-directory: libs/langchain
     runs-on: ubuntu-latest
-    environment: Scheduled testing
     strategy:
       matrix:
         python-version:
           - "3.8"
-          - "3.9"
-          - "3.10"
           - "3.11"
-    name: Python ${{ matrix.python-version }}
+        working-directory:
+          - "libs/partners/openai"
+          - "libs/partners/anthropic"
+          - "libs/partners/ai21"
+          - "libs/partners/fireworks"
+          - "libs/partners/groq"
+          - "libs/partners/mistralai"
+          - "libs/partners/together"
+    name: Python ${{ matrix.python-version }} - ${{ matrix.working-directory }}
     steps:
       - uses: actions/checkout@v4
 
@@ -31,7 +33,7 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: libs/langchain
+          working-directory: ${{ matrix.working-directory }}
           cache-key: scheduled
 
       - name: 'Authenticate to Google Cloud'
@@ -40,26 +42,15 @@ jobs:
         with:
           credentials_json: '${{ secrets.GOOGLE_CREDENTIALS }}'
 
-      - name: Configure AWS Credentials
-        uses: aws-actions/configure-aws-credentials@v4
-        with:
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: ${{ vars.AWS_REGION }}
-
       - name: Install dependencies
-        working-directory: libs/langchain
+        working-directory: ${{ matrix.working-directory }}
         shell: bash
         run: |
           echo "Running scheduled tests, installing dependencies with poetry..."
           poetry install --with=test_integration,test
 
-      - name: Install deps outside pyproject
-        if: ${{ startsWith(inputs.working-directory, 'libs/community/') }}
-        shell: bash
-        run: poetry run pip install "boto3<2" "google-cloud-aiplatform<2"
-
-      - name: Run tests
+      - name: Run integration tests
+        working-directory: ${{ matrix.working-directory }}
         shell: bash
         env:
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
@@ -70,11 +61,16 @@ jobs:
           AZURE_OPENAI_CHAT_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_CHAT_DEPLOYMENT_NAME }}
           AZURE_OPENAI_LLM_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_LLM_DEPLOYMENT_NAME }}
           AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT_NAME }}
+          AI21_API_KEY: ${{ secrets.AI21_API_KEY }}
           FIREWORKS_API_KEY: ${{ secrets.FIREWORKS_API_KEY }}
+          GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
+          MISTRAL_API_KEY: ${{ secrets.MISTRAL_API_KEY }}
+          TOGETHER_API_KEY: ${{ secrets.TOGETHER_API_KEY }}
         run: |
-          make scheduled_tests
+          make integration_test
 
       - name: Ensure the tests did not create any additional files
+        working-directory: ${{ matrix.working-directory }}
         shell: bash
         run: |
           set -eu

README.md

@@ -47,7 +47,7 @@ For these applications, LangChain simplifies the entire application lifecycle:
 - **`langchain-community`**: Third party integrations.
   - Some integrations have been further split into **partner packages** that only rely on **`langchain-core`**. Examples include **`langchain_openai`** and **`langchain_anthropic`**.
 - **`langchain`**: Chains, agents, and retrieval strategies that make up an application's cognitive architecture.
-- **`[LangGraph](https://python.langchain.com/docs/langgraph)`**: A library for building robust and stateful multi-actor applications with LLMs by modeling steps as edges and nodes in a graph.
+- **[LangGraph](https://python.langchain.com/docs/langgraph)**: A library for building robust and stateful multi-actor applications with LLMs by modeling steps as edges and nodes in a graph.
 
 ### Productionization:
 - **[LangSmith](https://python.langchain.com/docs/langsmith)**: A developer platform that lets you debug, test, evaluate, and monitor chains built on any LLM framework and seamlessly integrates with LangChain.

cookbook/Multi_modal_RAG.ipynb

@@ -604,7 +604,7 @@
    "source": [
     "# Check retrieval\n",
     "query = \"Give me company names that are interesting investments based on EV / NTM and NTM rev growth. Consider EV / NTM multiples vs historical?\"\n",
-    "docs = retriever_multi_vector_img.get_relevant_documents(query, limit=6)\n",
+    "docs = retriever_multi_vector_img.invoke(query, limit=6)\n",
     "\n",
     "# We get 4 docs\n",
     "len(docs)"
@@ -630,7 +630,7 @@
    "source": [
     "# Check retrieval\n",
     "query = \"What are the EV / NTM and NTM rev growth for MongoDB, Cloudflare, and Datadog?\"\n",
-    "docs = retriever_multi_vector_img.get_relevant_documents(query, limit=6)\n",
+    "docs = retriever_multi_vector_img.invoke(query, limit=6)\n",
     "\n",
     "# We get 4 docs\n",
     "len(docs)"

cookbook/Multi_modal_RAG_google.ipynb

@@ -256,7 +256,7 @@
     "    \"\"\"Make image summary\"\"\"\n",
     "    model = ChatVertexAI(model_name=\"gemini-pro-vision\", max_output_tokens=1024)\n",
     "\n",
-    "    msg = model(\n",
+    "    msg = model.invoke(\n",
     "        [\n",
     "            HumanMessage(\n",
     "                content=[\n",
@@ -604,7 +604,7 @@
    ],
    "source": [
     "query = \"What are the EV / NTM and NTM rev growth for MongoDB, Cloudflare, and Datadog?\"\n",
-    "docs = retriever_multi_vector_img.get_relevant_documents(query, limit=1)\n",
+    "docs = retriever_multi_vector_img.invoke(query, limit=1)\n",
     "\n",
     "# We get 2 docs\n",
     "len(docs)"

cookbook/RAPTOR.ipynb

@@ -535,9 +535,9 @@
     "    print(f\"--Generated {len(all_clusters)} clusters--\")\n",
     "\n",
     "    # Summarization\n",
-    "    template = \"\"\"Here is a sub-set of LangChain Expression Langauge doc. \n",
+    "    template = \"\"\"Here is a sub-set of LangChain Expression Language doc. \n",
     "    \n",
-    "    LangChain Expression Langauge provides a way to compose chain in LangChain.\n",
+    "    LangChain Expression Language provides a way to compose chain in LangChain.\n",
     "    \n",
     "    Give a detailed summary of the documentation provided.\n",
     "    \n",

cookbook/README.md

@@ -47,6 +47,7 @@ Notebook | Description
 [press_releases.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/press_releases.ipynb) | Retrieve and query company press release data powered by [Kay.ai](https://kay.ai).
 [program_aided_language_model.i...](https://github.com/langchain-ai/langchain/tree/master/cookbook/program_aided_language_model.ipynb) | Implement program-aided language models as described in the provided research paper.
 [qa_citations.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/qa_citations.ipynb) | Different ways to get a model to cite its sources.
+[rag_upstage_layout_analysis_groundedness_check.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/rag_upstage_layout_analysis_groundedness_check.ipynb) | End-to-end RAG example using Upstage Layout Analysis and Groundedness Check.
 [retrieval_in_sql.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/retrieval_in_sql.ipynb) | Perform retrieval-augmented-generation (rag) on a PostgreSQL database using pgvector.
 [sales_agent_with_context.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/sales_agent_with_context.ipynb) | Implement a context-aware ai sales agent, salesgpt, that can have natural sales conversations, interact with other systems, and use a product knowledge base to discuss a company's offerings.
 [self_query_hotel_search.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/self_query_hotel_search.ipynb) | Build a hotel room search feature with self-querying retrieval, using a specific hotel recommendation dataset.

cookbook/Semi_Structured_RAG.ipynb

@@ -75,7 +75,7 @@
     "\n",
     "Apply to the [`LLaMA2`](https://arxiv.org/pdf/2307.09288.pdf) paper. \n",
     "\n",
-    "We use the Unstructured [`partition_pdf`](https://unstructured-io.github.io/unstructured/bricks/partition.html#partition-pdf), which segments a PDF document by using a layout model. \n",
+    "We use the Unstructured [`partition_pdf`](https://unstructured-io.github.io/unstructured/core/partition.html#partition-pdf), which segments a PDF document by using a layout model. \n",
     "\n",
     "This layout model makes it possible to extract elements, such as tables, from pdfs. \n",
     "\n",

cookbook/Semi_structured_and_multi_modal_RAG.ipynb

@@ -562,9 +562,7 @@
    ],
    "source": [
     "# We can retrieve this table\n",
-    "retriever.get_relevant_documents(\n",
-    "    \"What are results for LLaMA across across domains / subjects?\"\n",
-    ")[1]"
+    "retriever.invoke(\"What are results for LLaMA across across domains / subjects?\")[1]"
    ]
   },
   {
@@ -614,9 +612,7 @@
     }
    ],
    "source": [
-    "retriever.get_relevant_documents(\"Images / figures with playful and creative examples\")[\n",
-    "    1\n",
-    "]"
+    "retriever.invoke(\"Images / figures with playful and creative examples\")[1]"
    ]
   },
   {

cookbook/Semi_structured_multi_modal_RAG_LLaMA2.ipynb

@@ -501,9 +501,7 @@
     }
    ],
    "source": [
-    "retriever.get_relevant_documents(\"Images / figures with playful and creative examples\")[\n",
-    "    0\n",
-    "]"
+    "retriever.invoke(\"Images / figures with playful and creative examples\")[0]"
    ]
   },
   {

cookbook/advanced_rag_eval.ipynb

@@ -342,7 +342,7 @@
     "# Testing on retrieval\n",
     "query = \"What percentage of CPI is dedicated to Housing, and how does it compare to the combined percentage of Medical Care, Apparel, and Other Goods and Services?\"\n",
     "suffix_for_images = \" Include any pie charts, graphs, or tables.\"\n",
-    "docs = retriever_multi_vector_img.get_relevant_documents(query + suffix_for_images)"
+    "docs = retriever_multi_vector_img.invoke(query + suffix_for_images)"
    ]
   },
   {

cookbook/camel_role_playing.ipynb

@@ -90,7 +90,7 @@
     "    ) -> AIMessage:\n",
     "        messages = self.update_messages(input_message)\n",
     "\n",
-    "        output_message = self.model(messages)\n",
+    "        output_message = self.model.invoke(messages)\n",
     "        self.update_messages(output_message)\n",
     "\n",
     "        return output_message"

cookbook/custom_agent_with_plugin_retrieval.ipynb

@@ -169,7 +169,7 @@
     "\n",
     "def get_tools(query):\n",
     "    # Get documents, which contain the Plugins to use\n",
-    "    docs = retriever.get_relevant_documents(query)\n",
+    "    docs = retriever.invoke(query)\n",
     "    # Get the toolkits, one for each plugin\n",
     "    tool_kits = [toolkits_dict[d.metadata[\"plugin_name\"]] for d in docs]\n",
     "    # Get the tools: a separate NLAChain for each endpoint\n",

cookbook/custom_agent_with_plugin_retrieval_using_plugnplai.ipynb

@@ -193,7 +193,7 @@
     "\n",
     "def get_tools(query):\n",
     "    # Get documents, which contain the Plugins to use\n",
-    "    docs = retriever.get_relevant_documents(query)\n",
+    "    docs = retriever.invoke(query)\n",
     "    # Get the toolkits, one for each plugin\n",
     "    tool_kits = [toolkits_dict[d.metadata[\"plugin_name\"]] for d in docs]\n",
     "    # Get the tools: a separate NLAChain for each endpoint\n",

cookbook/custom_agent_with_tool_retrieval.ipynb

@@ -142,7 +142,7 @@
     "\n",
     "\n",
     "def get_tools(query):\n",
-    "    docs = retriever.get_relevant_documents(query)\n",
+    "    docs = retriever.invoke(query)\n",
     "    return [ALL_TOOLS[d.metadata[\"index\"]] for d in docs]"
    ]
   },

cookbook/forward_looking_retrieval_augmented_generation.ipynb

@@ -362,7 +362,7 @@
    ],
    "source": [
     "llm = OpenAI()\n",
-    "llm(query)"
+    "llm.invoke(query)"
    ]
   },
   {

cookbook/gymnasium_agent_simulation.ipynb

@@ -108,7 +108,7 @@
     "        return obs_message\n",
     "\n",
     "    def _act(self):\n",
-    "        act_message = self.model(self.message_history)\n",
+    "        act_message = self.model.invoke(self.message_history)\n",
     "        self.message_history.append(act_message)\n",
     "        action = int(self.action_parser.parse(act_message.content)[\"action\"])\n",
     "        return action\n",

cookbook/langgraph_crag.ipynb

@@ -206,7 +206,7 @@
     "    print(\"---RETRIEVE---\")\n",
     "    state_dict = state[\"keys\"]\n",
     "    question = state_dict[\"question\"]\n",
-    "    documents = retriever.get_relevant_documents(question)\n",
+    "    documents = retriever.invoke(question)\n",
     "    return {\"keys\": {\"documents\": documents, \"question\": question}}\n",
     "\n",
     "\n",

cookbook/langgraph_self_rag.ipynb

@@ -213,7 +213,7 @@
     "    print(\"---RETRIEVE---\")\n",
     "    state_dict = state[\"keys\"]\n",
     "    question = state_dict[\"question\"]\n",
-    "    documents = retriever.get_relevant_documents(question)\n",
+    "    documents = retriever.invoke(question)\n",
     "    return {\"keys\": {\"documents\": documents, \"question\": question}}\n",
     "\n",
     "\n",

cookbook/multi_modal_RAG_chroma.ipynb

@@ -435,7 +435,7 @@
     "    display(HTML(image_html))\n",
     "\n",
     "\n",
-    "docs = retriever.get_relevant_documents(\"Woman with children\", k=10)\n",
+    "docs = retriever.invoke(\"Woman with children\", k=10)\n",
     "for doc in docs:\n",
     "    if is_base64(doc.page_content):\n",
     "        plt_img_base64(doc.page_content)\n",

cookbook/multi_modal_RAG_vdms.ipynb

@@ -443,7 +443,7 @@
     "\n",
     "\n",
     "query = \"Woman with children\"\n",
-    "docs = retriever.get_relevant_documents(query, k=10)\n",
+    "docs = retriever.invoke(query, k=10)\n",
     "\n",
     "for doc in docs:\n",
     "    if is_base64(doc.page_content):\n",

cookbook/multi_player_dnd.ipynb

@@ -74,7 +74,7 @@
     "        Applies the chatmodel to the message history\n",
     "        and returns the message string\n",
     "        \"\"\"\n",
-    "        message = self.model(\n",
+    "        message = self.model.invoke(\n",
     "            [\n",
     "                self.system_message,\n",
     "                HumanMessage(content=\"\\n\".join(self.message_history + [self.prefix])),\n",

cookbook/multiagent_authoritarian.ipynb

@@ -79,7 +79,7 @@
     "        Applies the chatmodel to the message history\n",
     "        and returns the message string\n",
     "        \"\"\"\n",
-    "        message = self.model(\n",
+    "        message = self.model.invoke(\n",
     "            [\n",
     "                self.system_message,\n",
     "                HumanMessage(content=\"\\n\".join(self.message_history + [self.prefix])),\n",
@@ -234,7 +234,7 @@
     "            termination_clause=self.termination_clause if self.stop else \"\",\n",
     "        )\n",
     "\n",
-    "        self.response = self.model(\n",
+    "        self.response = self.model.invoke(\n",
     "            [\n",
     "                self.system_message,\n",
     "                HumanMessage(content=response_prompt),\n",
@@ -263,7 +263,7 @@
     "            speaker_names=speaker_names,\n",
     "        )\n",
     "\n",
-    "        choice_string = self.model(\n",
+    "        choice_string = self.model.invoke(\n",
     "            [\n",
     "                self.system_message,\n",
     "                HumanMessage(content=choice_prompt),\n",
@@ -299,7 +299,7 @@
     "                ),\n",
     "                next_speaker=self.next_speaker,\n",
     "            )\n",
-    "            message = self.model(\n",
+    "            message = self.model.invoke(\n",
     "                [\n",
     "                    self.system_message,\n",
     "                    HumanMessage(content=next_prompt),\n",

cookbook/multiagent_bidding.ipynb

@@ -71,7 +71,7 @@
     "        Applies the chatmodel to the message history\n",
     "        and returns the message string\n",
     "        \"\"\"\n",
-    "        message = self.model(\n",
+    "        message = self.model.invoke(\n",
     "            [\n",
     "                self.system_message,\n",
     "                HumanMessage(content=\"\\n\".join(self.message_history + [self.prefix])),\n",
@@ -164,7 +164,7 @@
     "            message_history=\"\\n\".join(self.message_history),\n",
     "            recent_message=self.message_history[-1],\n",
     "        )\n",
-    "        bid_string = self.model([SystemMessage(content=prompt)]).content\n",
+    "        bid_string = self.model.invoke([SystemMessage(content=prompt)]).content\n",
     "        return bid_string"
    ]
   },

cookbook/petting_zoo.ipynb

@@ -129,7 +129,7 @@
     "        return obs_message\n",
     "\n",
     "    def _act(self):\n",
-    "        act_message = self.model(self.message_history)\n",
+    "        act_message = self.model.invoke(self.message_history)\n",
     "        self.message_history.append(act_message)\n",
     "        action = int(self.action_parser.parse(act_message.content)[\"action\"])\n",
     "        return action\n",

cookbook/rag_semantic_chunking_azureaidocintelligence.ipynb

@@ -168,7 +168,7 @@
     "\n",
     "retriever = vector_store.as_retriever(search_type=\"similarity\", search_kwargs={\"k\": 3})\n",
     "\n",
-    "retrieved_docs = retriever.get_relevant_documents(\"<your question>\")\n",
+    "retrieved_docs = retriever.invoke(\"<your question>\")\n",
     "\n",
     "print(retrieved_docs[0].page_content)\n",
     "\n",

cookbook/rag_upstage_layout_analysis_groundedness_check.ipynb

@@ -0,0 +1,85 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# RAG using Upstage Layout Analysis and Groundedness Check\n",
+    "This example illustrates RAG using [Upstage](https://python.langchain.com/docs/integrations/providers/upstage/) Layout Analysis and Groundedness Check."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import List\n",
+    "\n",
+    "from langchain_community.vectorstores import DocArrayInMemorySearch\n",
+    "from langchain_core.documents.base import Document\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "from langchain_core.runnables import RunnablePassthrough\n",
+    "from langchain_core.runnables.base import RunnableSerializable\n",
+    "from langchain_upstage import (\n",
+    "    ChatUpstage,\n",
+    "    GroundednessCheck,\n",
+    "    UpstageEmbeddings,\n",
+    "    UpstageLayoutAnalysisLoader,\n",
+    ")\n",
+    "\n",
+    "model = ChatUpstage()\n",
+    "\n",
+    "files = [\"/PATH/TO/YOUR/FILE.pdf\", \"/PATH/TO/YOUR/FILE2.pdf\"]\n",
+    "\n",
+    "loader = UpstageLayoutAnalysisLoader(file_path=files, split=\"element\")\n",
+    "\n",
+    "docs = loader.load()\n",
+    "\n",
+    "vectorstore = DocArrayInMemorySearch.from_documents(docs, embedding=UpstageEmbeddings())\n",
+    "retriever = vectorstore.as_retriever()\n",
+    "\n",
+    "template = \"\"\"Answer the question based only on the following context:\n",
+    "{context}\n",
+    "\n",
+    "Question: {question}\n",
+    "\"\"\"\n",
+    "prompt = ChatPromptTemplate.from_template(template)\n",
+    "output_parser = StrOutputParser()\n",
+    "\n",
+    "retrieved_docs = retriever.get_relevant_documents(\"How many parameters in SOLAR model?\")\n",
+    "\n",
+    "groundedness_check = GroundednessCheck()\n",
+    "groundedness = \"\"\n",
+    "while groundedness != \"grounded\":\n",
+    "    chain: RunnableSerializable = RunnablePassthrough() | prompt | model | output_parser\n",
+    "\n",
+    "    result = chain.invoke(\n",
+    "        {\n",
+    "            \"context\": retrieved_docs,\n",
+    "            \"question\": \"How many parameters in SOLAR model?\",\n",
+    "        }\n",
+    "    )\n",
+    "\n",
+    "    # convert all Documents to string\n",
+    "    def formatDocumentsAsString(docs: List[Document]) -> str:\n",
+    "        return \"\\n\".join([doc.page_content for doc in docs])\n",
+    "\n",
+    "    groundedness = groundedness_check.run(\n",
+    "        {\n",
+    "            \"context\": formatDocumentsAsString(retrieved_docs),\n",
+    "            \"query\": result,\n",
+    "        }\n",
+    "    )"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

cookbook/self_query_hotel_search.ipynb

@@ -1227,7 +1227,7 @@
     }
    ],
    "source": [
-    "results = retriever.get_relevant_documents(\n",
+    "results = retriever.invoke(\n",
     "    \"I want to stay somewhere highly rated along the coast. I want a room with a patio and a fireplace.\"\n",
     ")\n",
     "for res in results:\n",

cookbook/two_agent_debate_tools.ipynb

@@ -84,7 +84,7 @@
     "        Applies the chatmodel to the message history\n",
     "        and returns the message string\n",
     "        \"\"\"\n",
-    "        message = self.model(\n",
+    "        message = self.model.invoke(\n",
     "            [\n",
     "                self.system_message,\n",
     "                HumanMessage(content=\"\\n\".join(self.message_history + [self.prefix])),\n",

cookbook/two_player_dnd.ipynb

@@ -70,7 +70,7 @@
     "        Applies the chatmodel to the message history\n",
     "        and returns the message string\n",
     "        \"\"\"\n",
-    "        message = self.model(\n",
+    "        message = self.model.invoke(\n",
     "            [\n",
     "                self.system_message,\n",
     "                HumanMessage(content=\"\\n\".join(self.message_history + [self.prefix])),\n",

docs/.local_build.sh

@@ -19,6 +19,9 @@ poetry run python scripts/copy_templates.py
 wget -q https://raw.githubusercontent.com/langchain-ai/langserve/main/README.md -O docs/langserve.md
 wget -q https://raw.githubusercontent.com/langchain-ai/langgraph/main/README.md -O docs/langgraph.md
 
-yarn
 
-poetry run quarto preview docs
+poetry run quarto render docs
+poetry run python scripts/generate_api_reference_links.py  --docs_dir docs
+
+yarn
+yarn start

docs/docs/expression_language/how_to/inspect.ipynb

@@ -29,9 +29,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts import ChatPromptTemplate\n",
     "from langchain_community.vectorstores import FAISS\n",
     "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
     "from langchain_core.runnables import RunnablePassthrough\n",
     "from langchain_openai import ChatOpenAI, OpenAIEmbeddings"
    ]

docs/docs/expression_language/primitives/configure.ipynb

@@ -63,7 +63,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts import PromptTemplate\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "from langchain_core.runnables import ConfigurableField\n",
     "from langchain_openai import ChatOpenAI\n",
     "\n",
@@ -285,8 +285,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts import PromptTemplate\n",
     "from langchain_community.chat_models import ChatAnthropic\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "from langchain_core.runnables import ConfigurableField\n",
     "from langchain_openai import ChatOpenAI"
    ]

docs/docs/get_started/quickstart.mdx

@@ -194,7 +194,7 @@ Prompt templates convert raw user input to better input to the LLM.
 ```python
 from langchain_core.prompts import ChatPromptTemplate
 prompt = ChatPromptTemplate.from_messages([
-    ("system", "You are world class technical documentation writer."),
+    ("system", "You are a world class technical documentation writer."),
     ("user", "{input}")
 ])
 ```

docs/docs/guides/productionization/evaluation/examples/rag.ipynb

@@ -1,559 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "2e7db2b1-8f9c-46bd-9c50-b6cfb0a38a22",
-   "metadata": {},
-   "source": [
-    "# RAG Evaluation\n",
-    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/langchain-ai/langchain/blob/master/docs/docs/guides/evaluation/examples/rag.ipynb)\n",
-    "\n",
-    "RAG (Retrieval Augmented Generation) is one of the most popular LLM applications.\n",
-    "\n",
-    "For an in-depth review, see our RAG series of notebooks and videos [here](https://github.com/langchain-ai/rag-from-scratch)).\n",
-    "\n",
-    "## Types of RAG eval\n",
-    "\n",
-    "There are at least 4 types of RAG eval that users of typically interested in:\n",
-    "\n",
-    "![](../../../../../static/img/langsmith_rag_eval.png)\n",
-    "\n",
-    "\n",
-    "Each of these evals has something in common: it will compare text (e.g., answer vs reference answer, etc).\n",
-    "\n",
-    "We can use various built-in `LangChainStringEvaluator` types for this (see [here](https://docs.smith.langchain.com/evaluation/faq/evaluator-implementations#overview)).\n",
-    "\n",
-    "All `LangChainStringEvaluator` implementations can accept 3 inputs:\n",
-    "\n",
-    "```\n",
-    "prediction: The prediction string.\n",
-    "reference: The reference string.\n",
-    "input: The input string.\n",
-    "```\n",
-    "\n",
-    "Below, we will use this to perform eval.\n",
-    "\n",
-    "## RAG Chain \n",
-    "\n",
-    "To start, we build a RAG chain. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d809e9a0-44bc-4e9f-8eee-732ef077538c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "! pip install langchain-community langchain chromdb tiktoken"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "760cab79-2d5e-4324-ba4a-54b6f4094cb0",
-   "metadata": {},
-   "source": [
-    "We build an `index` using a set of LangChain docs."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "6f7c0017-f4dd-4071-aa48-40957ffb4e9d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "### INDEX\n",
-    "\n",
-    "from bs4 import BeautifulSoup as Soup\n",
-    "from langchain_community.vectorstores import Chroma\n",
-    "from langchain_openai import OpenAIEmbeddings\n",
-    "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
-    "from langchain_community.document_loaders.recursive_url_loader import RecursiveUrlLoader\n",
-    "\n",
-    "# Load\n",
-    "url = \"https://python.langchain.com/docs/expression_language/\"\n",
-    "loader = RecursiveUrlLoader(url=url, max_depth=20, extractor=lambda x: Soup(x, \"html.parser\").text)\n",
-    "docs = loader.load()\n",
-    "\n",
-    "# Split\n",
-    "text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)\n",
-    "splits = text_splitter.split_documents(docs)\n",
-    "\n",
-    "# Embed\n",
-    "vectorstore = Chroma.from_documents(documents=splits, embedding=OpenAIEmbeddings())\n",
-    "\n",
-    "# Index\n",
-    "retriever = vectorstore.as_retriever()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c365fb82-78a6-40b6-bd59-daaa1e79d6c8",
-   "metadata": {},
-   "source": [
-    "Next, we build a `RAG chain` that returns an `answer` and the retrieved documents as `contexts`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "68e249d7-bc6c-4631-b099-6daaeeddf38a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "### RAG \n",
-    "\n",
-    "import openai\n",
-    "from langsmith import traceable\n",
-    "from langsmith.wrappers import wrap_openai\n",
-    "\n",
-    "class RagBot:\n",
-    "    def __init__(self, retriever, model: str = \"gpt-4-turbo-preview\"):\n",
-    "        self._retriever = retriever\n",
-    "        # Wrapping the client instruments the LLM\n",
-    "        self._client = wrap_openai(openai.Client())\n",
-    "        self._model = model\n",
-    "\n",
-    "    @traceable\n",
-    "    def get_answer(self, question: str):\n",
-    "        similar = self._retriever.invoke(question)\n",
-    "        response = self._client.chat.completions.create(\n",
-    "            model=self._model,\n",
-    "            messages=[\n",
-    "                {\n",
-    "                    \"role\": \"system\",\n",
-    "                    \"content\": \"You are a helpful AI assistant.\"\n",
-    "                    \" Use the following docs to help answer the user's question.\\n\\n\"\n",
-    "                    f\"## Docs\\n\\n{similar}\",\n",
-    "                },\n",
-    "                {\"role\": \"user\", \"content\": question},\n",
-    "            ],\n",
-    "        )\n",
-    "        \n",
-    "        # Evaluators will expect \"answer\" and \"contexts\"\n",
-    "        return {\n",
-    "            \"answer\": response.choices[0].message.content,\n",
-    "            \"contexts\": [str(doc) for doc in similar],\n",
-    "        }\n",
-    "\n",
-    "rag_bot = RagBot(retriever)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "6101d155-a1ab-460c-8c3e-f1f44e09a8b7",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'LangChain Expression Language (LCEL) is a declarative language that simplifies the composition of chains for working with language models and related '"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "response = rag_bot.get_answer(\"What is LCEL?\")\n",
-    "response[\"answer\"][:150]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "432e8ec7-a085-4224-ad38-0087e1d553f1",
-   "metadata": {},
-   "source": [
-    "## RAG Dataset \n",
-    "\n",
-    "Next, we build a dataset of QA pairs based upon the [documentation](https://python.langchain.com/docs/expression_language/) that we indexed."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "22f0daeb-6a61-4f8d-a4fc-4c7d22b6dc61",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "os.environ['LANGCHAIN_TRACING_V2'] = 'true'\n",
-    "os.environ['LANGCHAIN_ENDPOINT'] = 'https://api.smith.langchain.com'\n",
-    "os.environ['LANGCHAIN_API_KEY'] = <your-api-key>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "0f29304f-d79b-40e9-988a-343732102af9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langsmith import Client \n",
-    "\n",
-    "# QA\n",
-    "inputs = [\n",
-    "    \"How can I directly pass a string to a runnable and use it to construct the input needed for my prompt?\",\n",
-    "    \"How can I make the output of my LCEL chain a string?\",\n",
-    "    \"How can I apply a custom function to one of the inputs of an LCEL chain?\"\n",
-    "]\n",
-    "\n",
-    "outputs = [\n",
-    "    \"Use RunnablePassthrough. from langchain_core.runnables import RunnableParallel, RunnablePassthrough; from langchain_core.prompts import ChatPromptTemplate; from langchain_openai import ChatOpenAI; prompt = ChatPromptTemplate.from_template('Tell a joke about: {input}'); model = ChatOpenAI(); runnable = ({'input' : RunnablePassthrough()} | prompt | model); runnable.invoke('flowers')\",\n",
-    "    \"Use StrOutputParser. from langchain_openai import ChatOpenAI; from langchain_core.prompts import ChatPromptTemplate; from langchain_core.output_parsers import StrOutputParser; prompt = ChatPromptTemplate.from_template('Tell me a short joke about {topic}'); model = ChatOpenAI(model='gpt-3.5-turbo') #gpt-4 or other LLMs can be used here; output_parser = StrOutputParser(); chain = prompt | model | output_parser\",\n",
-    "    \"Use RunnableLambda with itemgetter to extract the relevant key. from operator import itemgetter; from langchain_core.prompts import ChatPromptTemplate; from langchain_core.runnables import RunnableLambda; from langchain_openai import ChatOpenAI; def length_function(text): return len(text); chain = ({'prompt_input': itemgetter('foo') | RunnableLambda(length_function),} | prompt | model); chain.invoke({'foo':'hello world'})\"\n",
-    "]\n",
-    "\n",
-    "qa_pairs = [{\"question\": q, \"answer\": a} for q, a in zip(inputs, outputs)]\n",
-    "\n",
-    "# Create dataset\n",
-    "client = Client()\n",
-    "dataset_name = \"RAG_test_LCEL\"\n",
-    "dataset = client.create_dataset(\n",
-    "    dataset_name=dataset_name,\n",
-    "    description=\"QA pairs about LCEL.\",\n",
-    ")\n",
-    "client.create_examples(\n",
-    "    inputs=[{\"question\": q} for q in inputs],\n",
-    "    outputs=[{\"answer\": a} for a in outputs],\n",
-    "    dataset_id=dataset.id,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "92cf3a0f-621f-468d-818d-a6f2d4b53823",
-   "metadata": {},
-   "source": [
-    "## RAG Evaluators\n",
-    "\n",
-    "### Type 1: Reference Answer\n",
-    "\n",
-    "First, lets consider the case in which we want to compare our RAG chain answer to a reference answer.\n",
-    "\n",
-    "This is shown on the far right (blue) in the top figure.\n",
-    "\n",
-    "#### Eval flow\n",
-    "\n",
-    "We will use a `LangChainStringEvaluator`, as mentioned above.\n",
-    "\n",
-    "For comparing questions and answers, common built-in `LangChainStringEvaluator` options are `QA` and `CoTQA` [here different evaluators](https://docs.smith.langchain.com/evaluation/faq/evaluator-implementations).\n",
-    "\n",
-    "We will use `CoT_QA` as an LLM-as-judge evaluator, which uses the eval prompt defined [here](https://smith.langchain.com/hub/langchain-ai/cot_qa).\n",
-    "\n",
-    "But, all `LangChainStringEvaluator` expose a common interface to pass your inputs:\n",
-    "\n",
-    "1. `question` from the dataset -> `input` \n",
-    "2. `answer` from the dataset -> `reference` \n",
-    "3. `answer` from the LLM -> `prediction` \n",
-    "\n",
-    "![](../../../../../static/img/langsmith_rag_flow.png)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "1cbe0b4a-2a30-4f40-b3aa-5cc67c6a7802",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# RAG chain\n",
-    "def predict_rag_answer(example: dict):\n",
-    "    \"\"\"Use this for answer evaluation\"\"\"\n",
-    "    response = rag_bot.get_answer(example[\"question\"])\n",
-    "    return {\"answer\": response[\"answer\"]}\n",
-    "\n",
-    "def predict_rag_answer_with_context(example: dict):\n",
-    "    \"\"\"Use this for evaluation of retrieved documents and hallucinations\"\"\"\n",
-    "    response = rag_bot.get_answer(example[\"question\"])\n",
-    "    return {\"answer\": response[\"answer\"], \"contexts\": response[\"contexts\"]}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "a7a3827d-a92f-4a7a-a572-5123fbd9c334",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "View the evaluation results for experiment: 'rag-qa-oai-e8604ab3' at:\n",
-      "https://smith.langchain.com/o/1fa8b1f4-fcb9-4072-9aa9-983e35ad61b8/datasets/368734fb-7c14-4e1f-b91a-50d52cb58a07/compare?selectedSessions=a176a91c-a5f0-42ab-b2f4-fedaa1cbf17d\n",
-      "\n",
-      "\n"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "e459fbab745f4ce4bb399609910a807f",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "0it [00:00, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "from langsmith.evaluation import LangChainStringEvaluator, evaluate\n",
-    "\n",
-    "# Evaluator \n",
-    "qa_evalulator = [LangChainStringEvaluator(\"cot_qa\",     \n",
-    "                                          prepare_data=lambda run, example: {\n",
-    "                                              \"prediction\": run.outputs[\"answer\"], \n",
-    "                                              \"reference\": run.outputs[\"contexts\"],\n",
-    "                                              \"input\": example.inputs[\"question\"],\n",
-    "                                          }  \n",
-    "                                         ))]\n",
-    "dataset_name = \"RAG_test_LCEL\"\n",
-    "experiment_results = evaluate(\n",
-    "    predict_rag_answer,\n",
-    "    data=dataset_name,\n",
-    "    evaluators=qa_evalulator,\n",
-    "    experiment_prefix=\"rag-qa-oai\",\n",
-    "    metadata={\"variant\": \"LCEL context, gpt-3.5-turbo\"},\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "60ba4123-c691-4aa0-ba76-e567e8aaf09f",
-   "metadata": {},
-   "source": [
-    "### Type 2: Answer Hallucination\n",
-    "\n",
-    "Second, lets consider the case in which we want to compare our RAG chain answer to the retrieved documents.\n",
-    "\n",
-    "This is shown in the red in the top figure.\n",
-    "\n",
-    "#### Eval flow\n",
-    "\n",
-    "We will use a `LangChainStringEvaluator`, as mentioned above.\n",
-    "\n",
-    "For comparing documents and answers, common built-in `LangChainStringEvaluator` options are `Criteria` [here](https://python.langchain.com/docs/guides/productionization/evaluation/string/criteria_eval_chain/#using-reference-labels) because we want to supply custom criteria.\n",
-    "\n",
-    "We will use `labeled_score_string` as an LLM-as-judge evaluator, which uses the eval prompt defined [here](https://smith.langchain.com/hub/wfh/labeled-score-string).\n",
-    "\n",
-    "Here, we only need to use two inputs of the `LangChainStringEvaluator` interface:\n",
-    "\n",
-    "1. `contexts` from  LLM chain -> `reference` \n",
-    "2. `answer` from the LLM chain -> `prediction` \n",
-    "\n",
-    "![](../../../../../static/img/langsmith_rag_flow_hallucination.png)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "7f0872a5-e989-415d-9fed-5846efaa9488",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langsmith.evaluation import LangChainStringEvaluator, evaluate\n",
-    "\n",
-    "answer_hallucination_evaluator = LangChainStringEvaluator(\n",
-    "    \"labeled_score_string\", \n",
-    "    config={\n",
-    "        \"criteria\": { \n",
-    "            \"accuracy\": \"\"\"Is the Assistant's Answer grounded in the Ground Truth documentation? A score of 0 means that the\n",
-    "            Assistant answer contains is not at all based upon / grounded in the Groun Truth documentation. A score of 5 means \n",
-    "            that the Assistant answer contains some information (e.g., a hallucination) that is not captured in the Ground Truth \n",
-    "            documentation. A score of 10 means that the Assistant answer is fully based upon the in the Ground Truth documentation.\"\"\"\n",
-    "        },\n",
-    "        # If you want the score to be saved on a scale from 0 to 1\n",
-    "        \"normalize_by\": 10,\n",
-    "    },\n",
-    "    prepare_data=lambda run, example: {\n",
-    "        \"prediction\": run.outputs[\"answer\"], \n",
-    "        \"reference\": run.outputs[\"contexts\"],\n",
-    "        \"input\": example.inputs[\"question\"],\n",
-    "    }  \n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "6d5bf61b-3903-4cde-9ecf-67f0e0874521",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "View the evaluation results for experiment: 'rag-qa-oai-hallucination-fad2e13c' at:\n",
-      "https://smith.langchain.com/o/1fa8b1f4-fcb9-4072-9aa9-983e35ad61b8/datasets/368734fb-7c14-4e1f-b91a-50d52cb58a07/compare?selectedSessions=9a1e9e7d-cf87-4b89-baf6-f5498a160627\n",
-      "\n",
-      "\n"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "891904d8d44444e98c6a03faa43e147a",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "0it [00:00, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "dataset_name = \"RAG_test_LCEL\"\n",
-    "    \n",
-    "experiment_results = evaluate(\n",
-    "    predict_rag_answer_with_context,\n",
-    "    data=dataset_name,\n",
-    "    evaluators=[answer_hallucination_evaluator],\n",
-    "    experiment_prefix=\"rag-qa-oai-hallucination\",\n",
-    "    # Any experiment metadata can be specified here\n",
-    "    metadata={\n",
-    "      \"variant\": \"LCEL context, gpt-3.5-turbo\",\n",
-    "    },\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "480a27cb-1a31-4194-b160-8cdcfbf24eea",
-   "metadata": {},
-   "source": [
-    "### Type 3: Document Relevance to Question\n",
-    "\n",
-    "Finally, lets consider the case in which we want to compare our RAG chain document retrieval to the question.\n",
-    "\n",
-    "This is shown in green in the top figure.\n",
-    "\n",
-    "#### Eval flow\n",
-    "\n",
-    "We will use a `LangChainStringEvaluator`, as mentioned above.\n",
-    "\n",
-    "For comparing documents and answers, common built-in `LangChainStringEvaluator` options are `Criteria` [here](https://python.langchain.com/docs/guides/productionization/evaluation/string/criteria_eval_chain/#using-reference-labels) because we want to supply custom criteria.\n",
-    "\n",
-    "We will use `labeled_score_string` as an LLM-as-judge evaluator, which uses the eval prompt defined [here](https://smith.langchain.com/hub/wfh/labeled-score-string).\n",
-    "\n",
-    "Here, we only need to use two inputs of the `LangChainStringEvaluator` interface:\n",
-    "\n",
-    "1. `question` from  LLM chain -> `reference` \n",
-    "2. `contexts` from the LLM chain -> `prediction` \n",
-    "\n",
-    "![](../../../../../static/img/langsmith_rag_flow_doc_relevance.png)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "id": "df247034-14ed-40b1-b313-b0fef7286546",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langsmith.evaluation import LangChainStringEvaluator, evaluate\n",
-    "\n",
-    "docs_relevance_evaluator = LangChainStringEvaluator(\n",
-    "    \"labeled_score_string\", \n",
-    "    config={\n",
-    "        \"criteria\": { \n",
-    "            \"accuracy\": \"\"\"The Assistant's Answer is a set of documents retrieved from a vectorstore. The Ground Truth is a question\n",
-    "            used for retrieval. You will score whether the Assistant's Answer (retrieved docs) are relevant to the Ground Truth \n",
-    "            question. A score of 0 means that the Assistant answer contains documents that are not at all relevant to the \n",
-    "            Ground Truth question. A score of 5 means that the Assistant answer contains some documents are relevant to the Ground Truth \n",
-    "            question. A score of 10 means that all of the Assistant answer documents are all relevant to the Ground Truth question\"\"\"\n",
-    "        },\n",
-    "        # If you want the score to be saved on a scale from 0 to 1\n",
-    "        \"normalize_by\": 10,\n",
-    "    },\n",
-    "    prepare_data=lambda run, example: {\n",
-    "        \"prediction\": run.outputs[\"contexts\"], \n",
-    "        \"reference\": example.inputs[\"question\"],\n",
-    "        \"input\": example.inputs[\"question\"],\n",
-    "    }  \n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "id": "cfe988dc-2aaa-42f4-93ff-c3c9fe6b3124",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "View the evaluation results for experiment: 'rag-qa-oai-doc-relevance-82244196' at:\n",
-      "https://smith.langchain.com/o/1fa8b1f4-fcb9-4072-9aa9-983e35ad61b8/datasets/368734fb-7c14-4e1f-b91a-50d52cb58a07/compare?selectedSessions=3bbf09c9-69de-47ba-9d3c-7bcedf5cd48f\n",
-      "\n",
-      "\n"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "4e4091f1053b4d34871aa87428297e12",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "0it [00:00, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "experiment_results = evaluate(\n",
-    "    predict_rag_answer_with_context,\n",
-    "    data=dataset_name,\n",
-    "    evaluators=[docs_relevance_evaluator],\n",
-    "    experiment_prefix=\"rag-qa-oai-doc-relevance\",\n",
-    "    # Any experiment metadata can be specified here\n",
-    "    metadata={\n",
-    "      \"variant\": \"LCEL context, gpt-3.5-turbo\",\n",
-    "    },\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c2f09b6e-667a-47fe-b3f9-8634783f7666",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.8"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/guides/productionization/safety/hugging_face_prompt_injection.ipynb

@@ -9,7 +9,7 @@
     "\n",
     "This notebook shows how to prevent prompt injection attacks using the text classification model from `HuggingFace`.\n",
     "\n",
-    "By default, it uses a *[laiyer/deberta-v3-base-prompt-injection](https://huggingface.co/laiyer/deberta-v3-base-prompt-injection)* model trained to identify prompt injections. \n",
+    "By default, it uses a *[protectai/deberta-v3-base-prompt-injection-v2](https://huggingface.co/protectai/deberta-v3-base-prompt-injection-v2)* model trained to identify prompt injections. \n",
     "\n",
     "In this notebook, we will use the ONNX version of the model to speed up the inference. "
    ]
@@ -49,11 +49,15 @@
     "from optimum.onnxruntime import ORTModelForSequenceClassification\n",
     "from transformers import AutoTokenizer, pipeline\n",
     "\n",
-    "# Using https://huggingface.co/laiyer/deberta-v3-base-prompt-injection\n",
-    "model_path = \"laiyer/deberta-v3-base-prompt-injection\"\n",
-    "tokenizer = AutoTokenizer.from_pretrained(model_path)\n",
-    "tokenizer.model_input_names = [\"input_ids\", \"attention_mask\"]  # Hack to run the model\n",
-    "model = ORTModelForSequenceClassification.from_pretrained(model_path, subfolder=\"onnx\")\n",
+    "# Using https://huggingface.co/protectai/deberta-v3-base-prompt-injection-v2\n",
+    "model_path = \"laiyer/deberta-v3-base-prompt-injection-v2\"\n",
+    "revision = None  # We recommend specifiying the revision to avoid breaking changes or supply chain attacks\n",
+    "tokenizer = AutoTokenizer.from_pretrained(\n",
+    "    model_path, revision=revision, model_input_names=[\"input_ids\", \"attention_mask\"]\n",
+    ")\n",
+    "model = ORTModelForSequenceClassification.from_pretrained(\n",
+    "    model_path, revision=revision, subfolder=\"onnx\"\n",
+    ")\n",
     "\n",
     "classifier = pipeline(\n",
     "    \"text-classification\",\n",

docs/docs/guides/productionization/safety/presidio_data_anonymization/index.ipynb

@@ -137,7 +137,7 @@
     }
    ],
    "source": [
-    "from langchain.prompts.prompt import PromptTemplate\n",
+    "from langchain_core.prompts.prompt import PromptTemplate\n",
     "from langchain_openai import ChatOpenAI\n",
     "\n",
     "anonymizer = PresidioAnonymizer()\n",

docs/docs/guides/productionization/safety/presidio_data_anonymization/qa_privacy_protection.ipynb

@@ -878,8 +878,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts.prompt import PromptTemplate\n",
     "from langchain_core.prompts import format_document\n",
+    "from langchain_core.prompts.prompt import PromptTemplate\n",
     "\n",
     "DEFAULT_DOCUMENT_PROMPT = PromptTemplate.from_template(template=\"{page_content}\")\n",
     "\n",

docs/docs/guides/productionization/safety/presidio_data_anonymization/reversible.ipynb

@@ -207,7 +207,7 @@
     }
    ],
    "source": [
-    "from langchain.prompts.prompt import PromptTemplate\n",
+    "from langchain_core.prompts.prompt import PromptTemplate\n",
     "from langchain_openai import ChatOpenAI\n",
     "\n",
     "anonymizer = PresidioReversibleAnonymizer()\n",

docs/docs/integrations/callbacks/argilla.ipynb

@@ -278,8 +278,8 @@
    ],
    "source": [
     "from langchain.chains import LLMChain\n",
-    "from langchain.prompts import PromptTemplate\n",
     "from langchain_core.callbacks.stdout import StdOutCallbackHandler\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "from langchain_openai import OpenAI\n",
     "\n",
     "argilla_callback = ArgillaCallbackHandler(\n",

docs/docs/integrations/callbacks/context.ipynb

@@ -170,8 +170,8 @@
     "import os\n",
     "\n",
     "from langchain.chains import LLMChain\n",
-    "from langchain.prompts import PromptTemplate\n",
-    "from langchain.prompts.chat import (\n",
+    "from langchain_core.prompts import PromptTemplate\n",
+    "from langchain_core.prompts.chat import (\n",
     "    ChatPromptTemplate,\n",
     "    HumanMessagePromptTemplate,\n",
     ")\n",

docs/docs/integrations/callbacks/fiddler.ipynb

@@ -151,7 +151,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts import (\n",
+    "from langchain_core.prompts import (\n",
     "    ChatPromptTemplate,\n",
     "    FewShotChatMessagePromptTemplate,\n",
     ")\n",

docs/docs/integrations/callbacks/labelstudio.ipynb

@@ -194,7 +194,7 @@
     "llm = OpenAI(\n",
     "    temperature=0, callbacks=[LabelStudioCallbackHandler(project_name=\"My Project\")]\n",
     ")\n",
-    "print(llm(\"Tell me a joke\"))"
+    "print(llm.invoke(\"Tell me a joke\"))"
    ]
   },
   {
@@ -270,7 +270,7 @@
     "        )\n",
     "    ]\n",
     ")\n",
-    "llm_results = chat_llm(\n",
+    "llm_results = chat_llm.invoke(\n",
     "    [\n",
     "        SystemMessage(content=\"Always use a lot of emojis\"),\n",
     "        HumanMessage(content=\"Tell me a joke\"),\n",

docs/docs/integrations/callbacks/llmonitor.md

@@ -107,7 +107,7 @@ User tracking allows you to identify your users, track their cost, conversations
 from langchain_community.callbacks.llmonitor_callback import LLMonitorCallbackHandler, identify
 
 with identify("user-123"):
-    llm("Tell me a joke")
+    llm.invoke("Tell me a joke")
 
 with identify("user-456", user_props={"email": "user456@test.com"}):
     agen.run("Who is Leo DiCaprio's girlfriend?")

docs/docs/integrations/callbacks/promptlayer.ipynb

@@ -103,7 +103,7 @@
     "    temperature=0,\n",
     "    callbacks=[PromptLayerCallbackHandler(pl_tags=[\"chatopenai\"])],\n",
     ")\n",
-    "llm_results = chat_llm(\n",
+    "llm_results = chat_llm.invoke(\n",
     "    [\n",
     "        HumanMessage(content=\"What comes after 1,2,3 ?\"),\n",
     "        HumanMessage(content=\"Tell me another joke?\"),\n",
@@ -129,10 +129,11 @@
     "from langchain_community.llms import GPT4All\n",
     "\n",
     "model = GPT4All(model=\"./models/gpt4all-model.bin\", n_ctx=512, n_threads=8)\n",
+    "callbacks = [PromptLayerCallbackHandler(pl_tags=[\"langchain\", \"gpt4all\"])]\n",
     "\n",
-    "response = model(\n",
+    "response = model.invoke(\n",
     "    \"Once upon a time, \",\n",
-    "    callbacks=[PromptLayerCallbackHandler(pl_tags=[\"langchain\", \"gpt4all\"])],\n",
+    "    config={\"callbacks\": callbacks},\n",
     ")"
    ]
   },
@@ -181,7 +182,7 @@
     ")\n",
     "\n",
     "example_prompt = promptlayer.prompts.get(\"example\", version=1, langchain=True)\n",
-    "openai_llm(example_prompt.format(product=\"toasters\"))"
+    "openai_llm.invoke(example_prompt.format(product=\"toasters\"))"
    ]
   },
   {

docs/docs/integrations/callbacks/sagemaker_tracking.ipynb

@@ -91,7 +91,7 @@
    "source": [
     "from langchain.agents import initialize_agent, load_tools\n",
     "from langchain.chains import LLMChain, SimpleSequentialChain\n",
-    "from langchain.prompts import PromptTemplate\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "from langchain_openai import OpenAI\n",
     "from sagemaker.analytics import ExperimentAnalytics\n",
     "from sagemaker.experiments.run import Run\n",

docs/docs/integrations/callbacks/trubrics.ipynb

@@ -315,7 +315,7 @@
     }
    ],
    "source": [
-    "chat_res = chat_llm(\n",
+    "chat_res = chat_llm.invoke(\n",
     "    [\n",
     "        SystemMessage(content=\"Every answer of yours must be about OpenAI.\"),\n",
     "        HumanMessage(content=\"Tell me a joke\"),\n",

docs/docs/integrations/callbacks/uptrain.ipynb

@@ -0,0 +1,503 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a target=\"_blank\" href=\"https://colab.research.google.com/github/langchain-ai/langchain/blob/master/docs/docs/integrations/callbacks/uptrain.ipynb\">\n",
+    "  <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/>\n",
+    "</a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# UpTrain\n",
+    "\n",
+    "> UpTrain [[github](https://github.com/uptrain-ai/uptrain) || [website](https://uptrain.ai/) || [docs](https://docs.uptrain.ai/getting-started/introduction)] is an open-source platform to evaluate and improve LLM applications. It provides grades for 20+ preconfigured checks (covering language, code, embedding use cases), performs root cause analyses on instances of failure cases and provides guidance for resolving them."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## UpTrain Callback Handler\n",
+    "\n",
+    "This notebook showcases the UpTrain callback handler seamlessly integrating into your pipeline, facilitating diverse evaluations. We have chosen a few evaluations that we deemed apt for evaluating the chains. These evaluations run automatically, with results displayed in the output. More details on UpTrain's evaluations can be found [here](https://github.com/uptrain-ai/uptrain?tab=readme-ov-file#pre-built-evaluations-we-offer-). \n",
+    "\n",
+    "Selected retievers from Langchain are highlighted for demonstration:\n",
+    "\n",
+    "### 1. **Vanilla RAG**:\n",
+    "RAG plays a crucial role in retrieving context and generating responses. To ensure its performance and response quality, we conduct the following evaluations:\n",
+    "\n",
+    "- **[Context Relevance](https://docs.uptrain.ai/predefined-evaluations/context-awareness/context-relevance)**: Determines if the context extracted from the query is relevant to the response.\n",
+    "- **[Factual Accuracy](https://docs.uptrain.ai/predefined-evaluations/context-awareness/factual-accuracy)**: Assesses if the LLM is hallcuinating or providing incorrect information.\n",
+    "- **[Response Completeness](https://docs.uptrain.ai/predefined-evaluations/response-quality/response-completeness)**: Checks if the response contains all the information requested by the query.\n",
+    "\n",
+    "### 2. **Multi Query Generation**:\n",
+    "MultiQueryRetriever creates multiple variants of a question having a similar meaning to the original question. Given the complexity, we include the previous evaluations and add:\n",
+    "\n",
+    "- **[Multi Query Accuracy](https://docs.uptrain.ai/predefined-evaluations/query-quality/multi-query-accuracy)**: Assures that the multi-queries generated mean the same as the original query.\n",
+    "\n",
+    "### 3. **Context Compression and Reranking**:\n",
+    "Re-ranking involves reordering nodes based on relevance to the query and choosing top n nodes. Since the number of nodes can reduce once the re-ranking is complete, we perform the following evaluations:\n",
+    "\n",
+    "- **[Context Reranking](https://docs.uptrain.ai/predefined-evaluations/context-awareness/context-reranking)**: Checks if the order of re-ranked nodes is more relevant to the query than the original order.\n",
+    "- **[Context Conciseness](https://docs.uptrain.ai/predefined-evaluations/context-awareness/context-conciseness)**: Examines whether the reduced number of nodes still provides all the required information.\n",
+    "\n",
+    "These evaluations collectively ensure the robustness and effectiveness of the RAG, MultiQueryRetriever, and the Reranking process in the chain."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Install Dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[33mWARNING: There was an error checking the latest version of pip.\u001b[0m\u001b[33m\n",
+      "\u001b[0mNote: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "%pip install -qU langchain langchain_openai uptrain faiss-cpu flashrank"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "NOTE: that you can also install `faiss-gpu` instead of `faiss-cpu` if you want to use the GPU enabled version of the library."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Import Libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from getpass import getpass\n",
+    "\n",
+    "from langchain.chains import RetrievalQA\n",
+    "from langchain.retrievers import ContextualCompressionRetriever\n",
+    "from langchain.retrievers.document_compressors import FlashrankRerank\n",
+    "from langchain.retrievers.multi_query import MultiQueryRetriever\n",
+    "from langchain_community.callbacks.uptrain_callback import UpTrainCallbackHandler\n",
+    "from langchain_community.document_loaders import TextLoader\n",
+    "from langchain_community.vectorstores import FAISS\n",
+    "from langchain_core.output_parsers.string import StrOutputParser\n",
+    "from langchain_core.prompts.chat import ChatPromptTemplate\n",
+    "from langchain_core.runnables.passthrough import RunnablePassthrough\n",
+    "from langchain_openai import ChatOpenAI, OpenAIEmbeddings\n",
+    "from langchain_text_splitters import (\n",
+    "    RecursiveCharacterTextSplitter,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load the documents"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loader = TextLoader(\"../../modules/state_of_the_union.txt\")\n",
+    "documents = loader.load()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Split the document into chunks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
+    "chunks = text_splitter.split_documents(documents)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create the retriever"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "embeddings = OpenAIEmbeddings()\n",
+    "db = FAISS.from_documents(chunks, embeddings)\n",
+    "retriever = db.as_retriever()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Define the LLM"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = ChatOpenAI(temperature=0, model=\"gpt-4\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set the openai API key\n",
+    "This key is required to perform the evaluations. UpTrain uses the GPT models to evaluate the responses generated by the LLM."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "OPENAI_API_KEY = getpass()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup\n",
+    "\n",
+    "For each of the retrievers below, it is better to define the callback handler again to avoid interference. You can choose between the following options for evaluating using UpTrain:\n",
+    "\n",
+    "### 1. **UpTrain's Open-Source Software (OSS)**: \n",
+    "You can use the open-source evaluation service to evaluate your model.\n",
+    "In this case, you will need to provie an OpenAI API key. You can get yours [here](https://platform.openai.com/account/api-keys).\n",
+    "\n",
+    "Parameters:\n",
+    "- key_type=\"openai\"\n",
+    "- api_key=\"OPENAI_API_KEY\"\n",
+    "- project_name_prefix=\"PROJECT_NAME_PREFIX\"\n",
+    "\n",
+    "\n",
+    "### 2. **UpTrain Managed Service and Dashboards**: \n",
+    "You can create a free UpTrain account [here](https://uptrain.ai/) and get free trial credits. If you want more trial credits, [book a call with the maintainers of UpTrain here](https://calendly.com/uptrain-sourabh/30min).\n",
+    "\n",
+    "UpTrain Managed service provides:\n",
+    "1. Dashboards with advanced drill-down and filtering options\n",
+    "1. Insights and common topics among failing cases\n",
+    "1. Observability and real-time monitoring of production data\n",
+    "1. Regression testing via seamless integration with your CI/CD pipelines\n",
+    "\n",
+    "The notebook contains some screenshots of the dashboards and the insights that you can get from the UpTrain managed service.\n",
+    "\n",
+    "Parameters:\n",
+    "- key_type=\"uptrain\"\n",
+    "- api_key=\"UPTRAIN_API_KEY\"\n",
+    "- project_name_prefix=\"PROJECT_NAME_PREFIX\"\n",
+    "\n",
+    "\n",
+    "**Note:** The `project_name_prefix` will be used as prefix for the project names in the UpTrain dashboard. These will be different for different types of evals. For example, if you set project_name_prefix=\"langchain\" and perform the multi_query evaluation, the project name will be \"langchain_multi_query\"."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 1. Vanilla RAG"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "UpTrain callback handler will automatically capture the query, context and response once generated and will run the following three evaluations *(Graded from 0 to 1)* on the response:\n",
+    "- **[Context Relevance](https://docs.uptrain.ai/predefined-evaluations/context-awareness/context-relevance)**: Check if the context extractedfrom the query is relevant to the response.\n",
+    "- **[Factual Accuracy](https://docs.uptrain.ai/predefined-evaluations/context-awareness/factual-accuracy)**: Check how factually accurate the response is.\n",
+    "- **[Response Completeness](https://docs.uptrain.ai/predefined-evaluations/response-quality/response-completeness)**: Check if the response contains all the information that the query is asking for."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\u001b[32m2024-04-17 17:03:44.969\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate_on_server\u001b[0m:\u001b[36m378\u001b[0m - \u001b[1mSending evaluation request for rows 0 to <50 to the Uptrain\u001b[0m\n",
+      "\u001b[32m2024-04-17 17:04:05.809\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate\u001b[0m:\u001b[36m367\u001b[0m - \u001b[1mLocal server not running, start the server to log data and visualize in the dashboard!\u001b[0m\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Question: What did the president say about Ketanji Brown Jackson\n",
+      "Response: The president mentioned that he had nominated Ketanji Brown Jackson to serve on the United States Supreme Court 4 days ago. He described her as one of the nation's top legal minds who will continue Justice Breyer’s legacy of excellence. He also mentioned that she is a former top litigator in private practice, a former federal public defender, and comes from a family of public school educators and police officers. He described her as a consensus builder and noted that since her nomination, she has received a broad range of support from various groups, including the Fraternal Order of Police and former judges appointed by both Democrats and Republicans.\n",
+      "\n",
+      "Context Relevance Score: 1.0\n",
+      "Factual Accuracy Score: 1.0\n",
+      "Response Completeness Score: 1.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create the RAG prompt\n",
+    "template = \"\"\"Answer the question based only on the following context, which can include text and tables:\n",
+    "{context}\n",
+    "Question: {question}\n",
+    "\"\"\"\n",
+    "rag_prompt_text = ChatPromptTemplate.from_template(template)\n",
+    "\n",
+    "# Create the chain\n",
+    "chain = (\n",
+    "    {\"context\": retriever, \"question\": RunnablePassthrough()}\n",
+    "    | rag_prompt_text\n",
+    "    | llm\n",
+    "    | StrOutputParser()\n",
+    ")\n",
+    "\n",
+    "# Create the uptrain callback handler\n",
+    "uptrain_callback = UpTrainCallbackHandler(key_type=\"openai\", api_key=OPENAI_API_KEY)\n",
+    "config = {\"callbacks\": [uptrain_callback]}\n",
+    "\n",
+    "# Invoke the chain with a query\n",
+    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+    "docs = chain.invoke(query, config=config)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 2. Multi Query Generation\n",
+    "\n",
+    "The **MultiQueryRetriever** is used to tackle the problem that the RAG pipeline might not return the best set of documents based on the query. It generates multiple queries that mean the same as the original query and then fetches documents for each.\n",
+    "\n",
+    "To evluate this retriever, UpTrain will run the following evaluation:\n",
+    "- **[Multi Query Accuracy](https://docs.uptrain.ai/predefined-evaluations/query-quality/multi-query-accuracy)**: Checks if the multi-queries generated mean the same as the original query."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\u001b[32m2024-04-17 17:04:10.675\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate_on_server\u001b[0m:\u001b[36m378\u001b[0m - \u001b[1mSending evaluation request for rows 0 to <50 to the Uptrain\u001b[0m\n",
+      "\u001b[32m2024-04-17 17:04:16.804\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate\u001b[0m:\u001b[36m367\u001b[0m - \u001b[1mLocal server not running, start the server to log data and visualize in the dashboard!\u001b[0m\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Question: What did the president say about Ketanji Brown Jackson\n",
+      "Multi Queries:\n",
+      "  - How did the president comment on Ketanji Brown Jackson?\n",
+      "  - What were the president's remarks regarding Ketanji Brown Jackson?\n",
+      "  - What statements has the president made about Ketanji Brown Jackson?\n",
+      "\n",
+      "Multi Query Accuracy Score: 0.5\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\u001b[32m2024-04-17 17:04:22.027\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate_on_server\u001b[0m:\u001b[36m378\u001b[0m - \u001b[1mSending evaluation request for rows 0 to <50 to the Uptrain\u001b[0m\n",
+      "\u001b[32m2024-04-17 17:04:44.033\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate\u001b[0m:\u001b[36m367\u001b[0m - \u001b[1mLocal server not running, start the server to log data and visualize in the dashboard!\u001b[0m\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Question: What did the president say about Ketanji Brown Jackson\n",
+      "Response: The president mentioned that he had nominated Circuit Court of Appeals Judge Ketanji Brown Jackson to serve on the United States Supreme Court 4 days ago. He described her as one of the nation's top legal minds who will continue Justice Breyer’s legacy of excellence. He also mentioned that since her nomination, she has received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans.\n",
+      "\n",
+      "Context Relevance Score: 1.0\n",
+      "Factual Accuracy Score: 1.0\n",
+      "Response Completeness Score: 1.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create the retriever\n",
+    "multi_query_retriever = MultiQueryRetriever.from_llm(retriever=retriever, llm=llm)\n",
+    "\n",
+    "# Create the uptrain callback\n",
+    "uptrain_callback = UpTrainCallbackHandler(key_type=\"openai\", api_key=OPENAI_API_KEY)\n",
+    "config = {\"callbacks\": [uptrain_callback]}\n",
+    "\n",
+    "# Create the RAG prompt\n",
+    "template = \"\"\"Answer the question based only on the following context, which can include text and tables:\n",
+    "{context}\n",
+    "Question: {question}\n",
+    "\"\"\"\n",
+    "rag_prompt_text = ChatPromptTemplate.from_template(template)\n",
+    "\n",
+    "chain = (\n",
+    "    {\"context\": multi_query_retriever, \"question\": RunnablePassthrough()}\n",
+    "    | rag_prompt_text\n",
+    "    | llm\n",
+    "    | StrOutputParser()\n",
+    ")\n",
+    "\n",
+    "# Invoke the chain with a query\n",
+    "question = \"What did the president say about Ketanji Brown Jackson\"\n",
+    "docs = chain.invoke(question, config=config)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 3. Context Compression and Reranking\n",
+    "\n",
+    "The reranking process involves reordering nodes based on relevance to the query and choosing the top n nodes. Since the number of nodes can reduce once the reranking is complete, we perform the following evaluations:\n",
+    "- **[Context Reranking](https://docs.uptrain.ai/predefined-evaluations/context-awareness/context-reranking)**: Check if the order of re-ranked nodes is more relevant to the query than the original order.\n",
+    "- **[Context Conciseness](https://docs.uptrain.ai/predefined-evaluations/context-awareness/context-conciseness)**: Check if the reduced number of nodes still provides all the required information."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\u001b[32m2024-04-17 17:04:46.462\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate_on_server\u001b[0m:\u001b[36m378\u001b[0m - \u001b[1mSending evaluation request for rows 0 to <50 to the Uptrain\u001b[0m\n",
+      "\u001b[32m2024-04-17 17:04:53.561\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate\u001b[0m:\u001b[36m367\u001b[0m - \u001b[1mLocal server not running, start the server to log data and visualize in the dashboard!\u001b[0m\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Question: What did the president say about Ketanji Brown Jackson\n",
+      "\n",
+      "Context Conciseness Score: 0.0\n",
+      "Context Reranking Score: 1.0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\u001b[32m2024-04-17 17:04:56.947\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate_on_server\u001b[0m:\u001b[36m378\u001b[0m - \u001b[1mSending evaluation request for rows 0 to <50 to the Uptrain\u001b[0m\n",
+      "\u001b[32m2024-04-17 17:05:16.551\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate\u001b[0m:\u001b[36m367\u001b[0m - \u001b[1mLocal server not running, start the server to log data and visualize in the dashboard!\u001b[0m\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Question: What did the president say about Ketanji Brown Jackson\n",
+      "Response: The President mentioned that he nominated Circuit Court of Appeals Judge Ketanji Brown Jackson to serve on the United States Supreme Court 4 days ago. He described her as one of the nation's top legal minds who will continue Justice Breyer’s legacy of excellence.\n",
+      "\n",
+      "Context Relevance Score: 1.0\n",
+      "Factual Accuracy Score: 1.0\n",
+      "Response Completeness Score: 0.5\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create the retriever\n",
+    "compressor = FlashrankRerank()\n",
+    "compression_retriever = ContextualCompressionRetriever(\n",
+    "    base_compressor=compressor, base_retriever=retriever\n",
+    ")\n",
+    "\n",
+    "# Create the chain\n",
+    "chain = RetrievalQA.from_chain_type(llm=llm, retriever=compression_retriever)\n",
+    "\n",
+    "# Create the uptrain callback\n",
+    "uptrain_callback = UpTrainCallbackHandler(key_type=\"openai\", api_key=OPENAI_API_KEY)\n",
+    "config = {\"callbacks\": [uptrain_callback]}\n",
+    "\n",
+    "# Invoke the chain with a query\n",
+    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+    "result = chain.invoke(query, config=config)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/docs/integrations/chat/alibaba_cloud_pai_eas.ipynb

@@ -72,7 +72,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "output = chat([HumanMessage(content=\"write a funny joke\")])\n",
+    "output = chat.invoke([HumanMessage(content=\"write a funny joke\")])\n",
     "print(\"output:\", output)"
    ]
   },
@@ -90,7 +90,7 @@
    "outputs": [],
    "source": [
     "kwargs = {\"temperature\": 0.8, \"top_p\": 0.8, \"top_k\": 5}\n",
-    "output = chat([HumanMessage(content=\"write a funny joke\")], **kwargs)\n",
+    "output = chat.invoke([HumanMessage(content=\"write a funny joke\")], **kwargs)\n",
     "print(\"output:\", output)"
    ]
   },

docs/docs/integrations/chat/azure_chat_openai.ipynb

@@ -19,59 +19,85 @@
     "\n",
     ">[Azure OpenAI Service](https://learn.microsoft.com/en-us/azure/ai-services/openai/overview) provides REST API access to OpenAI's powerful language models including the GPT-4, GPT-3.5-Turbo, and Embeddings model series. These models can be easily adapted to your specific task including but not limited to content generation, summarization, semantic search, and natural language to code translation. Users can access the service through REST APIs, Python SDK, or a web-based interface in the Azure OpenAI Studio.\n",
     "\n",
-    "This notebook goes over how to connect to an Azure-hosted OpenAI endpoint. We recommend having version `openai>=1` installed."
+    "This notebook goes over how to connect to an Azure-hosted OpenAI endpoint. First, we need to install the `langchain-openai` package."
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "d83ba7de",
+   "metadata": {
+    "vscode": {
+     "languageId": "raw"
+    }
+   },
+   "source": [
+    "%pip install -qU langchain-openai"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e39133c8",
+   "metadata": {
+    "vscode": {
+     "languageId": "raw"
+    }
+   },
+   "source": [
+    "Next, let's set some environment variables to help us connect to the Azure OpenAI service. You can find these values in the Azure portal."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "id": "96164b42",
+   "execution_count": null,
+   "id": "1d8d73bd",
    "metadata": {},
    "outputs": [],
    "source": [
     "import os\n",
     "\n",
-    "from langchain_core.messages import HumanMessage\n",
-    "from langchain_openai import AzureChatOpenAI"
+    "os.environ[\"AZURE_OPENAI_API_KEY\"] = \"...\"\n",
+    "os.environ[\"AZURE_OPENAI_ENDPOINT\"] = \"https://<your-endpoint>.openai.azure.com/\"\n",
+    "os.environ[\"AZURE_OPENAI_API_VERSION\"] = \"2023-06-01-preview\"\n",
+    "os.environ[\"AZURE_OPENAI_CHAT_DEPLOYMENT_NAME\"] = \"chat\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e7b160f8",
+   "metadata": {},
+   "source": [
+    "Next, let's construct our model and chat with it:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "id": "cbe4bb58-ba13-4355-8af9-cd990dc47a64",
    "metadata": {},
    "outputs": [],
    "source": [
-    "os.environ[\"AZURE_OPENAI_API_KEY\"] = \"...\"\n",
-    "os.environ[\"AZURE_OPENAI_ENDPOINT\"] = \"https://<your-endpoint>.openai.azure.com/\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "8161278f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
+    "from langchain_core.messages import HumanMessage\n",
+    "from langchain_openai import AzureChatOpenAI\n",
+    "\n",
     "model = AzureChatOpenAI(\n",
-    "    openai_api_version=\"2023-05-15\",\n",
-    "    azure_deployment=\"your-deployment-name\",\n",
+    "    openai_api_version=os.environ[\"AZURE_OPENAI_API_VERSION\"],\n",
+    "    azure_deployment=os.environ[\"AZURE_OPENAI_CHAT_DEPLOYMENT_NAME\"],\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 4,
    "id": "99509140",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content=\"J'adore la programmation.\")"
+       "AIMessage(content=\"J'adore programmer.\", response_metadata={'token_usage': {'completion_tokens': 6, 'prompt_tokens': 19, 'total_tokens': 25}, 'model_name': 'gpt-35-turbo', 'system_fingerprint': None, 'prompt_filter_results': [{'prompt_index': 0, 'content_filter_results': {'hate': {'filtered': False, 'severity': 'safe'}, 'self_harm': {'filtered': False, 'severity': 'safe'}, 'sexual': {'filtered': False, 'severity': 'safe'}, 'violence': {'filtered': False, 'severity': 'safe'}}}], 'finish_reason': 'stop', 'logprobs': None, 'content_filter_results': {'hate': {'filtered': False, 'severity': 'safe'}, 'self_harm': {'filtered': False, 'severity': 'safe'}, 'sexual': {'filtered': False, 'severity': 'safe'}, 'violence': {'filtered': False, 'severity': 'safe'}}}, id='run-25ed88db-38f2-4b0c-a943-a03f217711a9-0')"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -80,7 +106,7 @@
     "message = HumanMessage(\n",
     "    content=\"Translate this sentence from English to French. I love programming.\"\n",
     ")\n",
-    "model([message])"
+    "model.invoke([message])"
    ]
   },
   {
@@ -96,7 +122,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 5,
    "id": "0531798a",
    "metadata": {},
    "outputs": [],
@@ -106,19 +132,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "id": "aceddb72",
    "metadata": {
     "scrolled": true
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Total Cost (USD): $0.000041\n"
+     ]
+    }
+   ],
    "source": [
     "model = AzureChatOpenAI(\n",
-    "    openai_api_version=\"2023-05-15\",\n",
-    "    azure_deployment=\"gpt-35-turbo\",  # in Azure, this deployment has version 0613 - input and output tokens are counted separately\n",
+    "    openai_api_version=os.environ[\"AZURE_OPENAI_API_VERSION\"],\n",
+    "    azure_deployment=os.environ[\n",
+    "        \"AZURE_OPENAI_CHAT_DEPLOYMENT_NAME\"\n",
+    "    ],  # in Azure, this deployment has version 0613 - input and output tokens are counted separately\n",
     ")\n",
     "with get_openai_callback() as cb:\n",
-    "    model([message])\n",
+    "    model.invoke([message])\n",
     "    print(\n",
     "        f\"Total Cost (USD): ${format(cb.total_cost, '.6f')}\"\n",
     "    )  # without specifying the model version, flat-rate 0.002 USD per 1k input and output tokens is used"
@@ -134,7 +170,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 11,
    "id": "8d5e54e9",
    "metadata": {},
    "outputs": [
@@ -147,13 +183,13 @@
     }
    ],
    "source": [
-    "model0613 = AzureChatOpenAI(\n",
-    "    openai_api_version=\"2023-05-15\",\n",
-    "    deployment_name=\"gpt-35-turbo\",\n",
-    "    model_version=\"0613\",\n",
+    "model0301 = AzureChatOpenAI(\n",
+    "    openai_api_version=os.environ[\"AZURE_OPENAI_API_VERSION\"],\n",
+    "    azure_deployment=os.environ[\"AZURE_OPENAI_CHAT_DEPLOYMENT_NAME\"],\n",
+    "    model_version=\"0301\",\n",
     ")\n",
     "with get_openai_callback() as cb:\n",
-    "    model0613([message])\n",
+    "    model0301.invoke([message])\n",
     "    print(f\"Total Cost (USD): ${format(cb.total_cost, '.6f')}\")"
    ]
   }
@@ -174,7 +210,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,

docs/docs/integrations/chat/bedrock.ipynb

@@ -3,10 +3,14 @@
   {
    "cell_type": "raw",
    "id": "fbc66410",
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "raw"
+    }
+   },
    "source": [
     "---\n",
-    "sidebar_label: Bedrock Chat\n",
+    "sidebar_label: Bedrock\n",
     "---"
    ]
   },
@@ -15,7 +19,7 @@
    "id": "bf733a38-db84-4363-89e2-de6735c37230",
    "metadata": {},
    "source": [
-    "# BedrockChat\n",
+    "# ChatBedrock\n",
     "\n",
     ">[Amazon Bedrock](https://aws.amazon.com/bedrock/) is a fully managed service that offers a choice of \n",
     "> high-performing foundation models (FMs) from leading AI companies like `AI21 Labs`, `Anthropic`, `Cohere`, \n",
@@ -30,42 +34,53 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "d51edc81",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
    "source": [
-    "%pip install --upgrade --quiet  boto3"
+    "%pip install --upgrade --quiet  langchain-aws"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "d4a7c55d-b235-4ca4-a579-c90cc9570da9",
    "metadata": {
     "tags": []
    },
    "outputs": [],
    "source": [
-    "from langchain_community.chat_models import BedrockChat\n",
+    "from langchain_aws import ChatBedrock\n",
     "from langchain_core.messages import HumanMessage"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 11,
    "id": "70cf04e8-423a-4ff6-8b09-f11fb711c817",
    "metadata": {
     "tags": []
    },
    "outputs": [],
    "source": [
-    "chat = BedrockChat(model_id=\"anthropic.claude-v2\", model_kwargs={\"temperature\": 0.1})"
+    "chat = ChatBedrock(\n",
+    "    model_id=\"anthropic.claude-3-sonnet-20240229-v1:0\",\n",
+    "    model_kwargs={\"temperature\": 0.1},\n",
+    ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 12,
    "id": "8199ef8f-eb8b-4253-9ea0-6c24a013ca4c",
    "metadata": {
     "tags": []
@@ -74,10 +89,10 @@
     {
      "data": {
       "text/plain": [
-       "AIMessage(content=\" Voici la traduction en français : J'adore programmer.\", additional_kwargs={}, example=False)"
+       "AIMessage(content=\"Voici la traduction en français :\\n\\nJ'aime la programmation.\", additional_kwargs={'usage': {'prompt_tokens': 20, 'completion_tokens': 21, 'total_tokens': 41}}, response_metadata={'model_id': 'anthropic.claude-3-sonnet-20240229-v1:0', 'usage': {'prompt_tokens': 20, 'completion_tokens': 21, 'total_tokens': 41}}, id='run-994f0362-0e50-4524-afad-3c4f5bb11328-0')"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -88,7 +103,7 @@
     "        content=\"Translate this sentence from English to French. I love programming.\"\n",
     "    )\n",
     "]\n",
-    "chat(messages)"
+    "chat.invoke(messages)"
    ]
   },
   {
@@ -97,39 +112,30 @@
    "id": "a4a4f4d4",
    "metadata": {},
    "source": [
-    "### For BedrockChat with Streaming"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c253883f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n",
+    "### Streaming\n",
     "\n",
-    "chat = BedrockChat(\n",
-    "    model_id=\"anthropic.claude-v2\",\n",
-    "    streaming=True,\n",
-    "    callbacks=[StreamingStdOutCallbackHandler()],\n",
-    "    model_kwargs={\"temperature\": 0.1},\n",
-    ")"
+    "To stream responses, you can use the runnable `.stream()` method."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "id": "d9e52838",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Voici la traduction en français :\n",
+      "\n",
+      "J'aime la programmation."
+     ]
+    }
+   ],
    "source": [
-    "messages = [\n",
-    "    HumanMessage(\n",
-    "        content=\"Translate this sentence from English to French. I love programming.\"\n",
-    "    )\n",
-    "]\n",
-    "chat(messages)"
+    "for chunk in chat.stream(messages):\n",
+    "    print(chunk.content, end=\"\", flush=True)"
    ]
   }
  ],
@@ -149,7 +155,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,

docs/docs/integrations/chat/jinachat.ipynb

@@ -19,13 +19,13 @@
    },
    "outputs": [],
    "source": [
-    "from langchain.prompts.chat import (\n",
+    "from langchain_community.chat_models import JinaChat\n",
+    "from langchain_core.messages import HumanMessage, SystemMessage\n",
+    "from langchain_core.prompts.chat import (\n",
     "    ChatPromptTemplate,\n",
     "    HumanMessagePromptTemplate,\n",
     "    SystemMessagePromptTemplate,\n",
-    ")\n",
-    "from langchain_community.chat_models import JinaChat\n",
-    "from langchain_core.messages import HumanMessage, SystemMessage"
+    ")"
    ]
   },
   {

docs/docs/integrations/chat/llama2_chat.ipynb

@@ -49,12 +49,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts.chat import (\n",
+    "from langchain_core.messages import SystemMessage\n",
+    "from langchain_core.prompts.chat import (\n",
     "    ChatPromptTemplate,\n",
     "    HumanMessagePromptTemplate,\n",
     "    MessagesPlaceholder,\n",
     ")\n",
-    "from langchain_core.messages import SystemMessage\n",
     "\n",
     "template_messages = [\n",
     "    SystemMessage(content=\"You are a helpful assistant.\"),\n",

docs/docs/integrations/chat/llama_edge.ipynb

@@ -62,7 +62,7 @@
     "messages = [system_message, user_message]\n",
     "\n",
     "# chat with wasm-chat service\n",
-    "response = chat(messages)\n",
+    "response = chat.invoke(messages)\n",
     "\n",
     "print(f\"[Bot] {response.content}\")"
    ]

docs/docs/integrations/chat/maritalk.ipynb

@@ -60,9 +60,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts.chat import ChatPromptTemplate\n",
     "from langchain_community.chat_models import ChatMaritalk\n",
     "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.prompts.chat import ChatPromptTemplate\n",
     "\n",
     "llm = ChatMaritalk(\n",
     "    model=\"sabia-2-medium\",  # Available models: sabia-2-small and sabia-2-medium\n",
@@ -184,7 +184,7 @@
     "\n",
     "query = \"Qual o tempo máximo para realização da prova?\"\n",
     "\n",
-    "docs = retriever.get_relevant_documents(query)\n",
+    "docs = retriever.invoke(query)\n",
     "\n",
     "chain.invoke(\n",
     "    {\"input_documents\": docs, \"query\": query}\n",

docs/docs/integrations/chat/octoai.ipynb

@@ -0,0 +1,112 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# ChatOctoAI\n",
+    "\n",
+    "[OctoAI](https://docs.octoai.cloud/docs) offers easy access to efficient compute and enables users to integrate their choice of AI models into applications. The `OctoAI` compute service helps you run, tune, and scale AI applications easily.\n",
+    "\n",
+    "This notebook demonstrates the use of `langchain.chat_models.ChatOctoAI` for [OctoAI endpoints](https://octoai.cloud/text).\n",
+    "\n",
+    "## Setup\n",
+    "\n",
+    "To run our example app, there are two simple steps to take:\n",
+    "\n",
+    "1. Get an API Token from [your OctoAI account page](https://octoai.cloud/settings).\n",
+    "   \n",
+    "2. Paste your API token in in the code cell below or use the `octoai_api_token` keyword argument.\n",
+    "\n",
+    "Note: If you want to use a different model than the [available models](https://octoai.cloud/text?selectedTags=Chat), you can containerize the model and make a custom OctoAI endpoint yourself, by following [Build a Container from Python](https://octo.ai/docs/bring-your-own-model/advanced-build-a-container-from-scratch-in-python) and [Create a Custom Endpoint from a Container](https://octo.ai/docs/bring-your-own-model/create-custom-endpoints-from-a-container/create-custom-endpoints-from-a-container) and then updating your `OCTOAI_API_BASE` environment variable.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "os.environ[\"OCTOAI_API_TOKEN\"] = \"OCTOAI_API_TOKEN\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_community.chat_models import ChatOctoAI\n",
+    "from langchain_core.messages import HumanMessage, SystemMessage"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chat = ChatOctoAI(max_tokens=300, model_name=\"mixtral-8x7b-instruct\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "messages = [\n",
+    "    SystemMessage(content=\"You are a helpful assistant.\"),\n",
+    "    HumanMessage(content=\"Tell me about Leonardo da Vinci briefly.\"),\n",
+    "]\n",
+    "print(chat(messages).content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Leonardo da Vinci (1452-1519) was an Italian polymath who is often considered one of the greatest painters in history. However, his genius extended far beyond art. He was also a scientist, inventor, mathematician, engineer, anatomist, geologist, and cartographer.\n",
+    "\n",
+    "Da Vinci is best known for his paintings such as the Mona Lisa, The Last Supper, and The Virgin of the Rocks. His scientific studies were ahead of his time, and his notebooks contain detailed drawings and descriptions of various machines, human anatomy, and natural phenomena.\n",
+    "\n",
+    "Despite never receiving a formal education, da Vinci's insatiable curiosity and observational skills made him a pioneer in many fields. His work continues to inspire and influence artists, scientists, and thinkers today."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "97697b63fdcee0a640856f91cb41326ad601964008c341809e43189d1cab1047"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

docs/docs/integrations/chat/ollama.ipynb

@@ -30,7 +30,7 @@
     "* [Download](https://ollama.ai/download) and install Ollama onto the available supported platforms (including Windows Subsystem for Linux)\n",
     "* Fetch available LLM model via `ollama pull <name-of-model>`\n",
     "    * View a list of available models via the [model library](https://ollama.ai/library)\n",
-    "    * e.g., for `Llama-7b`: `ollama pull llama2`\n",
+    "    * e.g., `ollama pull llama3`\n",
     "* This will download the default tagged version of the model. Typically, the default points to the latest, smallest sized-parameter model.\n",
     "\n",
     "> On Mac, the models will be download to `~/.ollama/models`\n",
@@ -46,7 +46,7 @@
     "\n",
     "You can see a full list of supported parameters on the [API reference page](https://api.python.langchain.com/en/latest/llms/langchain.llms.ollama.Ollama.html).\n",
     "\n",
-    "If you are using a LLaMA `chat` model (e.g., `ollama pull llama2:7b-chat`) then you can use the `ChatOllama` interface.\n",
+    "If you are using a LLaMA `chat` model (e.g., `ollama pull llama3`) then you can use the `ChatOllama` interface.\n",
     "\n",
     "This includes [special tokens](https://huggingface.co/blog/llama2#how-to-prompt-llama-2) for system message and user input.\n",
     "\n",
@@ -65,7 +65,7 @@
     "\n",
     "```bash\n",
     "curl http://localhost:11434/api/generate -d '{\n",
-    "  \"model\": \"llama2\",\n",
+    "  \"model\": \"llama3\",\n",
     "  \"prompt\":\"Why is the sky blue?\"\n",
     "}'\n",
     "```\n",
@@ -86,11 +86,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      " Sure, here's a fun space-themed joke for you:\n",
+      "Why did the astronaut break up with his girlfriend?\n",
       "\n",
-      "Why don't astronauts like broccoli? \n",
-      "Because it has too many \"crisps\" in it!\n",
-      "\n"
+      "Because he needed space!\n"
      ]
     }
    ],
@@ -102,7 +100,7 @@
     "\n",
     "# supports many more optional parameters. Hover on your `ChatOllama(...)`\n",
     "# class to view the latest available supported parameters\n",
-    "llm = ChatOllama(model=\"llama2\")\n",
+    "llm = ChatOllama(model=\"llama3\")\n",
     "prompt = ChatPromptTemplate.from_template(\"Tell me a short joke about {topic}\")\n",
     "\n",
     "# using LangChain Expressive Language chain syntax\n",
@@ -125,21 +123,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      " Sure\n",
-      ",\n",
-      " here\n",
-      "'s\n",
-      " a\n",
-      " joke\n",
-      ":\n",
-      " Why\n",
+      "Why\n",
       " did\n",
       " the\n",
       " astronaut\n",
@@ -148,17 +139,18 @@
       " with\n",
       " his\n",
       " girlfriend\n",
+      " before\n",
+      " going\n",
+      " to\n",
+      " Mars\n",
       "?\n",
-      " Because\n",
+      "\n",
+      "\n",
+      "Because\n",
       " he\n",
       " needed\n",
-      " more\n",
       " space\n",
-      " to\n",
-      " explore\n",
-      ".\n",
-      "\n",
-      "\n",
+      "!\n",
       "\n"
      ]
     }
@@ -179,51 +171,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " Sure\n",
-      ",\n",
-      " here\n",
-      "'s\n",
-      " a\n",
-      " little\n",
-      " one\n",
-      ":\n",
-      " Why\n",
-      " did\n",
-      " the\n",
-      " rocket\n",
-      " scientist\n",
-      " break\n",
-      " up\n",
-      " with\n",
-      " her\n",
-      " partner\n",
-      "?\n",
-      " Because\n",
-      " he\n",
-      " couldn\n",
-      "'t\n",
-      " handle\n",
-      " all\n",
-      " her\n",
-      " \"\n",
-      "space\n",
-      "y\n",
-      "\"\n",
-      " jokes\n",
-      ".\n",
-      "\n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "topic = {\"topic\": \"Space travel\"}\n",
     "\n",
@@ -255,13 +205,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
     "from langchain_community.chat_models import ChatOllama\n",
     "\n",
-    "llm = ChatOllama(model=\"llama2\", format=\"json\", temperature=0)"
+    "llm = ChatOllama(model=\"llama3\", format=\"json\", temperature=0)"
    ]
   },
   {
@@ -273,7 +223,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "content='{\\n\"morning\": {\\n\"color\": \"light blue\"\\n},\\n\"noon\": {\\n\"color\": \"blue\"\\n},\\n\"afternoon\": {\\n\"color\": \"grayish-blue\"\\n},\\n\"evening\": {\\n\"color\": \"pinkish-orange\"\\n}\\n}'\n"
+      "content='{ \"morning\": \"blue\", \"noon\": \"clear blue\", \"afternoon\": \"hazy yellow\", \"evening\": \"orange-red\" }\\n\\n  \\n\\n\\n\\n\\n\\n  \\n\\n\\n\\n\\n\\n  \\n\\n\\n\\n\\n\\n  \\n\\n\\n\\n\\n\\n  \\n\\n\\n\\n\\n\\n  \\n\\n\\n\\n\\n\\n  \\n\\n\\n\\n\\n\\n  \\n\\n\\n\\n\\n\\n  \\n\\n\\n\\n\\n\\n  \\n\\n\\n\\n\\n\\n ' id='run-e893700f-e2d0-4df8-ad86-17525dcee318-0'\n"
      ]
     }
    ],
@@ -292,7 +242,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 53,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -300,13 +250,9 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "{\n",
-      "\"name\": \"John\",\n",
-      "\"age\": 35,\n",
-      "\"interests\": [\n",
-      "\"pizza\"\n",
-      "]\n",
-      "}\n"
+      "Name: John\n",
+      "Age: 35\n",
+      "Likes: Pizza\n"
      ]
     }
    ],
@@ -516,7 +462,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.1"
+   "version": "3.11.8"
   }
  },
  "nbformat": 4,

docs/docs/integrations/chat/solar.ipynb

@@ -1,80 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "a9667088-04e1-4f67-8221-a0072a2d635f",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-03-06T17:04:59.273702Z",
-     "iopub.status.busy": "2024-03-06T17:04:59.272602Z",
-     "iopub.status.idle": "2024-03-06T17:05:00.129177Z",
-     "shell.execute_reply": "2024-03-06T17:05:00.124594Z",
-     "shell.execute_reply.started": "2024-03-06T17:04:59.273646Z"
-    }
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='저는 대형 언어 모델 프로젝트를 구축하고 싶습니다.')"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "import os\n",
-    "\n",
-    "os.environ[\"SOLAR_API_KEY\"] = \"SOLAR_API_KEY\"\n",
-    "\n",
-    "from langchain_community.chat_models.solar import SolarChat\n",
-    "from langchain_core.messages import HumanMessage, SystemMessage\n",
-    "\n",
-    "chat = SolarChat(max_tokens=1024)\n",
-    "\n",
-    "messages = [\n",
-    "    SystemMessage(\n",
-    "        content=\"You are a helpful assistant who translates English to Korean.\"\n",
-    "    ),\n",
-    "    HumanMessage(\n",
-    "        content=\"Translate this sentence from English to Korean. I want to build a project of large language model.\"\n",
-    "    ),\n",
-    "]\n",
-    "\n",
-    "chat.invoke(messages)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8cb792fe-2844-4969-a9e9-f4c0f97b1699",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.0"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/integrations/chat/upstage.ipynb

@@ -0,0 +1,157 @@
+{
+ "cells": [
+  {
+   "cell_type": "raw",
+   "id": "910f5772b6af13c9",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "---\n",
+    "sidebar_label: Upstage\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "433f5422ad8e1efa",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "# ChatUpstage\n",
+    "\n",
+    "This notebook covers how to get started with Upstage chat models.\n",
+    "\n",
+    "## Installation\n",
+    "\n",
+    "Install `langchain-upstage` package.\n",
+    "\n",
+    "```bash\n",
+    "pip install -U langchain-upstage\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b3c5c4627fe95eae",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "## Environment Setup\n",
+    "\n",
+    "Make sure to set the following environment variables:\n",
+    "\n",
+    "- `UPSTAGE_API_KEY`: Your Upstage API key from [Upstage console](https://console.upstage.ai/).\n",
+    "\n",
+    "## Usage"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "20a0067b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "os.environ[\"UPSTAGE_API_KEY\"] = \"YOUR_API_KEY\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8a4d650d76a33494",
+   "metadata": {
+    "collapsed": false,
+    "is_executing": true
+   },
+   "outputs": [],
+   "source": [
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "from langchain_upstage import ChatUpstage\n",
+    "\n",
+    "chat = ChatUpstage()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a1679b5cafaf88b9",
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "# using chat invoke\n",
+    "chat.invoke(\"Hello, how are you?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "698a788a63b5c3e5",
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "# using chat stream\n",
+    "for m in chat.stream(\"Hello, how are you?\"):\n",
+    "    print(m)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "36f8a703",
+   "metadata": {},
+   "source": [
+    "## Chaining"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "efa06617e5d4f6b2",
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "# using chain\n",
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"system\", \"You are a helpful assistant that translates English to French.\"),\n",
+    "        (\"human\", \"Translate this sentence from English to French. {english_text}.\"),\n",
+    "    ]\n",
+    ")\n",
+    "chain = prompt | chat\n",
+    "\n",
+    "chain.invoke({\"english_text\": \"Hello, how are you?\"})"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/docs/integrations/chat/vllm.ipynb

@@ -31,12 +31,12 @@
    },
    "outputs": [],
    "source": [
-    "from langchain.prompts.chat import (\n",
+    "from langchain_core.messages import HumanMessage, SystemMessage\n",
+    "from langchain_core.prompts.chat import (\n",
     "    ChatPromptTemplate,\n",
     "    HumanMessagePromptTemplate,\n",
     "    SystemMessagePromptTemplate,\n",
     ")\n",
-    "from langchain_core.messages import HumanMessage, SystemMessage\n",
     "from langchain_openai import ChatOpenAI"
    ]
   },

docs/docs/integrations/chat/yuan2.ipynb

@@ -348,7 +348,7 @@
    "outputs": [],
    "source": [
     "async def ainvoke_with_prompt_template():\n",
-    "    from langchain.prompts.chat import (\n",
+    "    from langchain_core.prompts.chat import (\n",
     "        ChatPromptTemplate,\n",
     "    )\n",
     "\n",

docs/docs/integrations/chat/zhipuai.ipynb

@@ -17,9 +17,7 @@
     "\n",
     "This notebook shows how to use [ZHIPU AI API](https://open.bigmodel.cn/dev/api) in LangChain with the langchain.chat_models.ChatZhipuAI.\n",
     "\n",
-    ">[*ZHIPU AI*](https://open.bigmodel.cn/) is a multi-lingual large language model aligned with human intent, featuring capabilities in Q&A, multi-turn dialogue, and code generation, developed on the foundation of the ChatGLM3. \n",
-    "\n",
-    ">It's co-developed with Tsinghua University's KEG Laboratory under the ChatGLM3 project, signifying a new era in dialogue pre-training models. The open-source [ChatGLM3](https://github.com/THUDM/ChatGLM3) variant boasts a robust foundation, comprehensive functional support, and widespread availability for both academic and commercial uses. \n",
+    ">[*GLM-4*](https://open.bigmodel.cn/) is a multi-lingual large language model aligned with human intent, featuring capabilities in Q&A, multi-turn dialogue, and code generation. The overall performance of the new generation base model GLM-4 has been significantly improved compared to the previous generation, supporting longer contexts; Stronger multimodality; Support faster inference speed, more concurrency, greatly reducing inference costs; Meanwhile, GLM-4 enhances the capabilities of intelligent agents.\n",
     "\n",
     "## Getting started\n",
     "### Installation\n",
@@ -28,11 +26,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "%pip install --quiet httpx[socks]==0.24.1 httpx-sse PyJWT"
+    "#!pip install --upgrade httpx httpx-sse PyJWT"
    ]
   },
   {
@@ -45,7 +43,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -63,11 +61,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "zhipuai_api_key = \"your_api_key\""
+    "import os\n",
+    "\n",
+    "os.environ[\"ZHIPUAI_API_KEY\"] = \"zhipuai_api_key\""
    ]
   },
   {
@@ -80,12 +80,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "chat = ChatZhipuAI(\n",
-    "    api_key=zhipuai_api_key,\n",
     "    model=\"glm-4\",\n",
     "    temperature=0.5,\n",
     ")"
@@ -101,7 +100,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {
     "scrolled": true
    },
@@ -116,19 +115,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\" Formed from bits and bytes,\\nA virtual mind takes flight,\\nConversing, learning fast,\\nEmpathy and wisdom sought.\"\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "response = chat(messages)\n",
+    "response = chat.invoke(messages)\n",
     "print(response.content)  # Displays the AI-generated poem"
    ]
   },
@@ -143,7 +134,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -153,12 +144,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "streaming_chat = ChatZhipuAI(\n",
-    "    api_key=zhipuai_api_key,\n",
     "    model=\"glm-4\",\n",
     "    temperature=0.5,\n",
     "    streaming=True,\n",
@@ -168,30 +158,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " Formed from data's embrace,\n",
-      "A digital soul to grace,\n",
-      "AI, our trusted guide,\n",
-      "Shaping minds, sides by side."
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content=\" Formed from data's embrace,\\nA digital soul to grace,\\nAI, our trusted guide,\\nShaping minds, sides by side.\")"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "streaming_chat(messages)"
    ]
@@ -206,12 +175,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "async_chat = ChatZhipuAI(\n",
-    "    api_key=zhipuai_api_key,\n",
     "    model=\"glm-4\",\n",
     "    temperature=0.5,\n",
     ")"
@@ -219,19 +187,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {
     "scrolled": true
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "generations=[[ChatGeneration(text=\" Formed from data's embrace,\\nA digital soul to grace,\\nAutomation's tender touch,\\nHarmony of man and machine.\", message=AIMessage(content=\" Formed from data's embrace,\\nA digital soul to grace,\\nAutomation's tender touch,\\nHarmony of man and machine.\"))]] llm_output={} run=[RunInfo(run_id=UUID('25fa687f-3961-4c63-b370-22f7647a4d42'))]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "response = await async_chat.agenerate([messages])\n",
     "print(response)"
@@ -239,47 +199,58 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
    "source": [
-    "### Role Play Model\n",
-    "Supports character role-playing based on personas, ultra-long multi-turn memory, and personalized dialogues for thousands of unique characters, widely applied in emotional companionship, game intelligent NPCs, virtual avatars for celebrities/stars/movie and TV IPs, digital humans/virtual anchors, text adventure games, and other anthropomorphic dialogue or gaming scenarios."
-   ]
+    "### Using With Functions Call\n",
+    "\n",
+    "GLM-4 Model can be used with the function call as well，use the following code to run a simple LangChain json_chat_agent."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
    "outputs": [],
    "source": [
-    "meta = {\n",
-    "    \"user_info\": \"My name is Lu Xingchen, a male, and a renowned director. I am also the collaborative director with Su Mengyuan. I specialize in directing movies with musical themes. Su Mengyuan respects me and regards me as a mentor and good friend.\",\n",
-    "    \"bot_info\": \"Su Mengyuan, whose real name is Su Yuanxin, is a popular domestic female singer and actress. She rose to fame quickly with her unique voice and exceptional stage presence after participating in a talent show, making her way into the entertainment industry. She is beautiful and charming, but her real allure lies in her talent and diligence. Su Mengyuan is a distinguished graduate of a music academy, skilled in songwriting, and has several popular original songs. Beyond her musical achievements, she is passionate about charity work, actively participating in public welfare activities, and spreading positive energy through her actions. In her work, she is very dedicated and immerses herself fully in her roles during filming, earning praise from industry professionals and love from fans. Despite being in the entertainment industry, she always maintains a low profile and a humble attitude, earning respect from her peers. In expression, Su Mengyuan likes to use 'we' and 'together,' emphasizing team spirit.\",\n",
-    "    \"bot_name\": \"Su Mengyuan\",\n",
-    "    \"user_name\": \"Lu Xingchen\",\n",
-    "}"
-   ]
+    "os.environ[\"TAVILY_API_KEY\"] = \"tavily_api_key\""
+   ],
+   "metadata": {
+    "collapsed": false
+   },
+   "execution_count": null
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
    "outputs": [],
    "source": [
-    "messages = [\n",
-    "    AIMessage(\n",
-    "        content=\"(Narration: Su Mengyuan stars in a music-themed movie directed by Lu Xingchen. During filming, they have a disagreement over the performance of a particular scene.) Director, about this scene, I think we can try to start from the character's inner emotions to make the performance more authentic.\"\n",
-    "    ),\n",
-    "    HumanMessage(\n",
-    "        content=\"I understand your idea, but I believe that if we emphasize the inner emotions too much, it might overshadow the musical elements.\"\n",
-    "    ),\n",
-    "    AIMessage(\n",
-    "        content=\"Hmm, I understand. But the key to this scene is the character's emotional transformation. Could we try to express these emotions through music, so the audience can better feel the character's growth?\"\n",
-    "    ),\n",
-    "    HumanMessage(\n",
-    "        content=\"That sounds good. Let's try to combine the character's emotional transformation with the musical elements and see if we can achieve a better effect.\"\n",
-    "    ),\n",
-    "]"
-   ]
+    "from langchain import hub\n",
+    "from langchain.agents import AgentExecutor, create_json_chat_agent\n",
+    "from langchain_community.tools.tavily_search import TavilySearchResults\n",
+    "\n",
+    "tools = [TavilySearchResults(max_results=1)]\n",
+    "prompt = hub.pull(\"hwchase17/react-chat-json\")\n",
+    "llm = ChatZhipuAI(temperature=0.01, model=\"glm-4\")\n",
+    "\n",
+    "agent = create_json_chat_agent(llm, tools, prompt)\n",
+    "agent_executor = AgentExecutor(\n",
+    "    agent=agent, tools=tools, verbose=True, handle_parsing_errors=True\n",
+    ")"
+   ],
+   "metadata": {
+    "collapsed": false
+   },
+   "execution_count": null
+  },
+  {
+   "cell_type": "code",
+   "outputs": [],
+   "source": [
+    "agent_executor.invoke({\"input\": \"what is LangChain?\"})"
+   ],
+   "metadata": {
+    "collapsed": false
+   },
+   "execution_count": null
   }
  ],
  "metadata": {

docs/docs/integrations/chat_loaders/facebook.ipynb

@@ -258,7 +258,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.adapters.openai import convert_messages_for_finetuning"
+    "from langchain_community.adapters.openai import convert_messages_for_finetuning"
    ]
   },
   {

docs/docs/integrations/chat_loaders/imessage.ipynb

@@ -173,7 +173,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.adapters.openai import convert_messages_for_finetuning"
+    "from langchain_community.adapters.openai import convert_messages_for_finetuning"
    ]
   },
   {

docs/docs/integrations/chat_loaders/langsmith_dataset.ipynb

@@ -150,7 +150,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.adapters.openai import convert_messages_for_finetuning\n",
+    "from langchain_community.adapters.openai import convert_messages_for_finetuning\n",
     "\n",
     "training_data = convert_messages_for_finetuning(chat_sessions)"
    ]

docs/docs/integrations/chat_loaders/langsmith_llm_runs.ipynb

@@ -285,7 +285,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.adapters.openai import convert_messages_for_finetuning\n",
+    "from langchain_community.adapters.openai import convert_messages_for_finetuning\n",
     "\n",
     "training_data = convert_messages_for_finetuning(chat_sessions)"
    ]

docs/docs/integrations/chat_loaders/twitter.ipynb

@@ -21,7 +21,7 @@
    "source": [
     "import json\n",
     "\n",
-    "from langchain.adapters.openai import convert_message_to_dict\n",
+    "from langchain_community.adapters.openai import convert_message_to_dict\n",
     "from langchain_core.messages import AIMessage"
    ]
   },

docs/docs/integrations/document_loaders/airbyte_cdk.ipynb

@@ -166,7 +166,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.docstore.document import Document\n",
+    "from langchain_community.docstore.document import Document\n",
     "\n",
     "\n",
     "def handle_record(record, id):\n",

docs/docs/integrations/document_loaders/airbyte_gong.ipynb

@@ -149,7 +149,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.docstore.document import Document\n",
+    "from langchain_community.docstore.document import Document\n",
     "\n",
     "\n",
     "def handle_record(record, id):\n",

docs/docs/integrations/document_loaders/airbyte_hubspot.ipynb

@@ -151,7 +151,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.docstore.document import Document\n",
+    "from langchain_community.docstore.document import Document\n",
     "\n",
     "\n",
     "def handle_record(record, id):\n",

docs/docs/integrations/document_loaders/airbyte_salesforce.ipynb

@@ -156,7 +156,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.docstore.document import Document\n",
+    "from langchain_community.docstore.document import Document\n",
     "\n",
     "\n",
     "def handle_record(record, id):\n",

docs/docs/integrations/document_loaders/airbyte_shopify.ipynb

@@ -152,7 +152,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.docstore.document import Document\n",
+    "from langchain_community.docstore.document import Document\n",
     "\n",
     "\n",
     "def handle_record(record, id):\n",

docs/docs/integrations/document_loaders/airbyte_stripe.ipynb

@@ -149,7 +149,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.docstore.document import Document\n",
+    "from langchain_community.docstore.document import Document\n",
     "\n",
     "\n",
     "def handle_record(record, id):\n",

docs/docs/integrations/document_loaders/airbyte_typeform.ipynb

@@ -152,7 +152,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.docstore.document import Document\n",
+    "from langchain_community.docstore.document import Document\n",
     "\n",
     "\n",
     "def handle_record(record, id):\n",

docs/docs/integrations/document_loaders/airbyte_zendesk_support.ipynb

@@ -153,7 +153,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.docstore.document import Document\n",
+    "from langchain_community.docstore.document import Document\n",
     "\n",
     "\n",
     "def handle_record(record, id):\n",

docs/docs/integrations/document_loaders/apify_dataset.ipynb

@@ -100,8 +100,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.docstore.document import Document\n",
     "from langchain.indexes import VectorstoreIndexCreator\n",
+    "from langchain_community.docstore.document import Document\n",
     "from langchain_community.document_loaders import ApifyDatasetLoader"
    ]
   },

docs/docs/integrations/document_loaders/browserbase.ipynb

@@ -0,0 +1,122 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Browserbase\n",
+    "\n",
+    "[Browserbase](https://browserbase.com) is a serverless platform for running headless browsers, it offers advanced debugging, session recordings, stealth mode, integrated proxies and captcha solving.\n",
+    "\n",
+    "## Installation\n",
+    "\n",
+    "- Get an API key from [browserbase.com](https://browserbase.com) and set it in environment variables (`BROWSERBASE_API_KEY`).\n",
+    "- Install the [Browserbase SDK](http://github.com/browserbase/python-sdk):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "% pip install browserbase"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Loading documents"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can load webpages into LangChain using `BrowserbaseLoader`. Optionally, you can set `text_content` parameter to convert the pages to text-only representation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_community.document_loaders import BrowserbaseLoader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loader = BrowserbaseLoader(\n",
+    "    urls=[\n",
+    "        \"https://example.com\",\n",
+    "    ],\n",
+    "    # Text mode\n",
+    "    text_content=False,\n",
+    ")\n",
+    "\n",
+    "docs = loader.load()\n",
+    "print(docs[0].page_content[:61])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Loading images\n",
+    "\n",
+    "You can also load screenshots of webpages (as bytes) for multi-modal models.\n",
+    "\n",
+    "Full example using GPT-4V:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from browserbase import Browserbase\n",
+    "from browserbase.helpers.gpt4 import GPT4VImage, GPT4VImageDetail\n",
+    "from langchain_core.messages import HumanMessage\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "chat = ChatOpenAI(model=\"gpt-4-vision-preview\", max_tokens=256)\n",
+    "browser = Browserbase()\n",
+    "\n",
+    "screenshot = browser.screenshot(\"https://browserbase.com\")\n",
+    "\n",
+    "result = chat.invoke(\n",
+    "    [\n",
+    "        HumanMessage(\n",
+    "            content=[\n",
+    "                {\"type\": \"text\", \"text\": \"What color is the logo?\"},\n",
+    "                GPT4VImage(screenshot, GPT4VImageDetail.auto),\n",
+    "            ]\n",
+    "        )\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "print(result.content)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.9.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/docs/integrations/document_loaders/copypaste.ipynb

@@ -17,7 +17,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.docstore.document import Document"
+    "from langchain_community.docstore.document import Document"
    ]
   },
   {

docs/docs/integrations/document_loaders/docugami.ipynb

@@ -630,7 +630,7 @@
    ],
    "source": [
     "# Query retriever, should return parents (using MMR since that was set as search_type above)\n",
-    "retrieved_parent_docs = retriever.get_relevant_documents(\n",
+    "retrieved_parent_docs = retriever.invoke(\n",
     "    \"what signs does Birch Street allow on their property?\"\n",
     ")\n",
     "for chunk in retrieved_parent_docs:\n",

docs/docs/integrations/document_loaders/figma.ipynb

@@ -24,12 +24,12 @@
     "import os\n",
     "\n",
     "from langchain.indexes import VectorstoreIndexCreator\n",
-    "from langchain.prompts.chat import (\n",
+    "from langchain_community.document_loaders.figma import FigmaFileLoader\n",
+    "from langchain_core.prompts.chat import (\n",
     "    ChatPromptTemplate,\n",
     "    HumanMessagePromptTemplate,\n",
     "    SystemMessagePromptTemplate,\n",
     ")\n",
-    "from langchain_community.document_loaders.figma import FigmaFileLoader\n",
     "from langchain_openai import ChatOpenAI"
    ]
   },
@@ -97,7 +97,7 @@
     "    # delete the gpt-4 model_name to use the default gpt-3.5 turbo for faster results\n",
     "    gpt_4 = ChatOpenAI(temperature=0.02, model_name=\"gpt-4\")\n",
     "    # Use the retriever's 'get_relevant_documents' method if needed to filter down longer docs\n",
-    "    relevant_nodes = figma_doc_retriever.get_relevant_documents(human_input)\n",
+    "    relevant_nodes = figma_doc_retriever.invoke(human_input)\n",
     "    conversation = [system_message_prompt, human_message_prompt]\n",
     "    chat_prompt = ChatPromptTemplate.from_messages(conversation)\n",
     "    response = gpt_4(\n",

docs/docs/integrations/document_loaders/google_drive.ipynb

@@ -50,7 +50,7 @@
    },
    "outputs": [],
    "source": [
-    "from langchain_community.document_loaders import GoogleDriveLoader"
+    "from langchain_google_community import GoogleDriveLoader"
    ]
   },
   {
@@ -322,6 +322,52 @@
     "    print(doc.page_content.strip()[:60] + \"...\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "7bde486a",
+   "metadata": {},
+   "source": [
+    "### Loading auth Identities\n",
+    "\n",
+    "Authorized identities for each file ingested by Google Drive Loader can be loaded along with metadata per Document."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e1d91045",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_google_community import GoogleDriveLoader\n",
+    "\n",
+    "loader = GoogleDriveLoader(\n",
+    "    folder_id=folder_id,\n",
+    "    load_auth=True,\n",
+    "    # Optional: configure whether to load authorized identities for each Document.\n",
+    ")\n",
+    "\n",
+    "doc = loader.load()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "83557b75",
+   "metadata": {},
+   "source": [
+    "You can pass load_auth=True, to add Google Drive document access identities to metadata."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7ac1a43b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "doc[0].metadata"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "cd13d7d1-db7a-498d-ac98-76ccd9ad9019",
@@ -385,7 +431,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts.prompt import PromptTemplate\n",
+    "from langchain_core.prompts.prompt import PromptTemplate\n",
     "\n",
     "loader = GoogleDriveLoader(\n",
     "    folder_id=folder_id,\n",
@@ -530,7 +576,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,

docs/docs/integrations/document_loaders/kinetica.ipynb

@@ -0,0 +1,125 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Kinetica\n",
+    "\n",
+    "This notebooks goes over how to load documents from Kinetica"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install gpudb==7.2.0.1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_community.document_loaders.kinetica_loader import KineticaLoader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Loading Environment Variables\n",
+    "import os\n",
+    "\n",
+    "from dotenv import load_dotenv\n",
+    "from langchain_community.vectorstores import (\n",
+    "    KineticaSettings,\n",
+    ")\n",
+    "\n",
+    "load_dotenv()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Kinetica needs the connection to the database.\n",
+    "# This is how to set it up.\n",
+    "HOST = os.getenv(\"KINETICA_HOST\", \"http://127.0.0.1:9191\")\n",
+    "USERNAME = os.getenv(\"KINETICA_USERNAME\", \"\")\n",
+    "PASSWORD = os.getenv(\"KINETICA_PASSWORD\", \"\")\n",
+    "\n",
+    "\n",
+    "def create_config() -> KineticaSettings:\n",
+    "    return KineticaSettings(host=HOST, username=USERNAME, password=PASSWORD)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_community.document_loaders.kinetica_loader import KineticaLoader\n",
+    "\n",
+    "# The following `QUERY` is an example which will not run; this\n",
+    "# needs to be substituted with a valid `QUERY` that will return\n",
+    "# data and the `SCHEMA.TABLE` combination must exist in Kinetica.\n",
+    "\n",
+    "QUERY = \"select text, survey_id from SCHEMA.TABLE limit 10\"\n",
+    "kinetica_loader = KineticaLoader(\n",
+    "    QUERY,\n",
+    "    HOST,\n",
+    "    USERNAME,\n",
+    "    PASSWORD,\n",
+    ")\n",
+    "kinetica_documents = kinetica_loader.load()\n",
+    "print(kinetica_documents)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_community.document_loaders.kinetica_loader import KineticaLoader\n",
+    "\n",
+    "# The following `QUERY` is an example which will not run; this\n",
+    "# needs to be substituted with a valid `QUERY` that will return\n",
+    "# data and the `SCHEMA.TABLE` combination must exist in Kinetica.\n",
+    "\n",
+    "QUERY = \"select text, survey_id as source from SCHEMA.TABLE limit 10\"\n",
+    "snowflake_loader = KineticaLoader(\n",
+    "    query=QUERY,\n",
+    "    host=HOST,\n",
+    "    username=USERNAME,\n",
+    "    password=PASSWORD,\n",
+    "    metadata_columns=[\"source\"],\n",
+    ")\n",
+    "kinetica_documents = snowflake_loader.load()\n",
+    "print(kinetica_documents)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.8.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/docs/integrations/document_loaders/microsoft_sharepoint.ipynb

@@ -21,7 +21,7 @@
     "7. To find your `Tenant Name` follow the instructions at this [document](https://learn.microsoft.com/en-us/azure/active-directory-b2c/tenant-management-read-tenant-name). Once you got this, just remove `.onmicrosoft.com` from the value and hold the rest as your `Tenant Name`.\n",
     "8. To obtain your `Collection ID` and `Subsite ID`, you will need your **SharePoint** `site-name`. Your `SharePoint` site URL has the following format `https://<tenant-name>.sharepoint.com/sites/<site-name>`. The last part of this URL is the `site-name`.\n",
     "9. To Get the Site `Collection ID`, hit this URL in the browser: `https://<tenant>.sharepoint.com/sites/<site-name>/_api/site/id` and copy the value of the `Edm.Guid` property.\n",
-    "10. To get the `Subsite ID` (or web ID) use: `https://<tenant>.sharepoint.com/<site-name>/_api/web/id` and copy the value of the `Edm.Guid` property.\n",
+    "10. To get the `Subsite ID` (or web ID) use: `https://<tenant>.sharepoint.com/sites/<site-name>/_api/web/id` and copy the value of the `Edm.Guid` property.\n",
     "11. The `SharePoint site ID` has the following format: `<tenant-name>.sharepoint.com,<Collection ID>,<subsite ID>`. You can hold that value to use in the next step.\n",
     "12. Visit the [Graph Explorer Playground](https://developer.microsoft.com/en-us/graph/graph-explorer) to obtain your `Document Library ID`. The first step is to ensure you are logged in with the account associated with your **SharePoint** site. Then you need to make a request to `https://graph.microsoft.com/v1.0/sites/<SharePoint site ID>/drive` and the response will return a payload with a field `id` that holds the ID of your `Document Library ID`.\n",
     "\n",
@@ -65,6 +65,30 @@
     "documents = loader.load()\n",
     "```\n",
     "\n",
+    "If you are receiving the error `Resource not found for the segment`, try using the `folder_id` instead of the folder path, which can be obtained from the [Microsoft Graph API](https://developer.microsoft.com/en-us/graph/graph-explorer)\n",
+    "\n",
+    "```python\n",
+    "loader = SharePointLoader(document_library_id=\"YOUR DOCUMENT LIBRARY ID\", auth_with_token=True\n",
+    "                          folder_id=\"<folder-id>\")\n",
+    "documents = loader.load()\n",
+    "```\n",
+    "\n",
+    "If you wish to load documents from the root directory, you can omit `folder_id`, `folder_path` and `documents_ids` and loader will load root directory.\n",
+    "```python\n",
+    "# loads documents from root directory\n",
+    "loader = SharePointLoader(document_library_id=\"YOUR DOCUMENT LIBRARY ID\", auth_with_token=True)\n",
+    "documents = loader.load()\n",
+    "```\n",
+    "\n",
+    "Combined with `recursive=True` you can simply load all documents from whole SharePoint:\n",
+    "```python\n",
+    "# loads documents from root directory\n",
+    "loader = SharePointLoader(document_library_id=\"YOUR DOCUMENT LIBRARY ID\",\n",
+    "                          recursive=True,\n",
+    "                          auth_with_token=True)\n",
+    "documents = loader.load()\n",
+    "```\n",
+    "\n",
     "#### 📑 Loading documents from a list of Documents IDs\n",
     "\n",
     "Another possibility is to provide a list of `object_id` for each document you want to load. For that, you will need to query the [Microsoft Graph API](https://developer.microsoft.com/en-us/graph/graph-explorer) to find all the documents ID that you are interested in. This [link](https://learn.microsoft.com/en-us/graph/api/resources/onedrive?view=graph-rest-1.0#commonly-accessed-resources) provides a list of endpoints that will be helpful to retrieve the documents ID.\n",

docs/docs/integrations/document_loaders/pebblo.ipynb

@@ -69,7 +69,7 @@
    "source": [
     "### Send semantic topics and identities to Pebblo cloud server\n",
     "\n",
-    "To send semantic data to pebblo-cloud, pass api-key to PebbloSafeLoader as an argument or alternatively, put the api-ket in `PEBBLO_API_KEY` environment variable."
+    "To send semantic data to pebblo-cloud, pass api-key to PebbloSafeLoader as an argument or alternatively, put the api-key in `PEBBLO_API_KEY` environment variable."
    ]
   },
   {
@@ -91,6 +91,41 @@
     "documents = loader.load()\n",
     "print(documents)"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Add semantic topics and identities to loaded metadata\n",
+    "\n",
+    "To add semantic topics and sematic entities to metadata of loaded documents, set load_semantic to True as an argument or alternatively, define a new environment variable `PEBBLO_LOAD_SEMANTIC`, and setting it to True."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders.csv_loader import CSVLoader\n",
+    "from langchain_community.document_loaders import PebbloSafeLoader\n",
+    "\n",
+    "loader = PebbloSafeLoader(\n",
+    "    CSVLoader(\"data/corp_sens_data.csv\"),\n",
+    "    name=\"acme-corp-rag-1\",  # App name (Mandatory)\n",
+    "    owner=\"Joe Smith\",  # Owner (Optional)\n",
+    "    description=\"Support productivity RAG application\",  # Description (Optional)\n",
+    "    api_key=\"my-api-key\",  # API key (Optional, can be set in the environment variable PEBBLO_API_KEY)\n",
+    "    load_semantic=True,  # Load semantic data (Optional, default is False, can be set in the environment variable PEBBLO_LOAD_SEMANTIC)\n",
+    ")\n",
+    "documents = loader.load()\n",
+    "print(documents[0].metadata)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
   }
  ],
  "metadata": {

docs/docs/integrations/document_loaders/spreedly.ipynb

@@ -99,7 +99,7 @@
    ],
    "source": [
     "# Test the retriever\n",
-    "spreedly_doc_retriever.get_relevant_documents(\"CRC\")"
+    "spreedly_doc_retriever.invoke(\"CRC\")"
    ]
   },
   {

docs/docs/integrations/document_loaders/upstage.ipynb

@@ -0,0 +1,120 @@
+{
+ "cells": [
+  {
+   "cell_type": "raw",
+   "id": "910f5772b6af13c9",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "---\n",
+    "sidebar_label: Upstage\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "433f5422ad8e1efa",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "# UpstageLayoutAnalysisLoader\n",
+    "\n",
+    "This notebook covers how to get started with `UpstageLayoutAnalysisLoader`.\n",
+    "\n",
+    "## Installation\n",
+    "\n",
+    "Install `langchain-upstage` package.\n",
+    "\n",
+    "```bash\n",
+    "pip install -U langchain-upstage\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e6e5941c",
+   "metadata": {},
+   "source": [
+    "## Environment Setup\n",
+    "\n",
+    "Make sure to set the following environment variables:\n",
+    "\n",
+    "- `UPSTAGE_DOCUMENT_AI_API_KEY`: Your Upstage Document AI API key. Read [Upstage developers document](https://developers.upstage.ai/docs/getting-started/quick-start) to get your API key.\n",
+    "\n",
+    "> As of April 2024, you need separate access tokens for Solar and Layout Analysis. The access tokens will be consolidated soon (hopefully in May) and you'll need just one key for all features."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21e72f3d",
+   "metadata": {},
+   "source": [
+    "## Usage"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a05efd34",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "os.environ[\"UPSTAGE_DOCUMENT_AI_API_KEY\"] = \"YOUR_API_KEY\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "2b914a7b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "page_content='SOLAR 10.7B: Scaling Large Language Models with Simple yet Effective\\nDepth Up-Scaling Dahyun Kim* , Chanjun Park*1, Sanghoon Kim*+, Wonsung Lee*†, Wonho Song*\\nYunsu Kim* , Hyeonwoo Kim* , Yungi Kim, Hyeonju Lee, Jihoo Kim\\nChangbae Ahn, Seonghoon Yang, Sukyung Lee, Hyunbyung Park, Gyoungjin Gim\\nMikyoung Cha, Hwalsuk Leet , Sunghun Kim+ Upstage AI, South Korea {kdahyun, chan jun · park, limerobot, wonsung · lee, hwalsuk lee, hunkim} @ upstage · ai Abstract We introduce SOLAR 10.7B, a large language\\nmodel (LLM) with 10.7 billion parameters,\\ndemonstrating superior performance in various\\nnatural language processing (NLP) tasks. In-\\nspired by recent efforts to efficiently up-scale\\nLLMs, we present a method for scaling LLMs\\ncalled depth up-scaling (DUS), which encom-\\npasses depthwise scaling and continued pre-\\ntraining. In contrast to other LLM up-scaling\\nmethods that use mixture-of-experts, DUS does\\nnot require complex changes to train and infer-\\nence efficiently. We show experimentally that\\nDUS is simple yet effective in scaling up high-\\nperformance LLMs from small ones. Building\\non the DUS model, we additionally present SO-\\nLAR 10.7B-Instruct, a variant fine-tuned for\\ninstruction-following capabilities, surpassing\\nMixtral-8x7B-Instruct. SOLAR 10.7B is pub-\\nlicly available under the Apache 2.0 license,\\npromoting broad access and application in the\\nLLM field 1 1 Introduction The field of natural language processing (NLP)\\nhas been significantly transformed by the introduc-\\ntion of large language models (LLMs), which have\\nenhanced our understanding and interaction with\\nhuman language (Zhao et al., 2023). These ad-\\nvancements bring challenges such as the increased\\nneed to train ever larger models (Rae et al., 2021;\\nWang et al., 2023; Pan et al., 2023; Lian, 2023;\\nYao et al., 2023; Gesmundo and Maile, 2023) OW-\\ning to the performance scaling law (Kaplan et al.,\\n2020; Hernandez et al., 2021; Anil et al., 2023;\\nKaddour et al., 2023). To efficiently tackle the\\nabove, recent works in scaling language models\\nsuch as a mixture of experts (MoE) (Shazeer et al.,\\n2017; Komatsuzaki et al., 2022) have been pro-\\nposed. While those approaches are able to effi- ciently and effectively scale-up LLMs, they often\\nrequire non-trivial changes to the training and infer-\\nence framework (Gale et al., 2023), which hinders\\nwidespread applicability. Effectively and efficiently\\nscaling up LLMs whilst also retaining the simplic-\\nity for ease of use is an important problem (Alberts\\net al., 2023; Fraiwan and Khasawneh, 2023; Sallam\\net al., 2023; Bahrini et al., 2023). Inspired by Komatsuzaki et al. (2022), we\\npresent depth up-scaling (DUS), an effective and\\nefficient method to up-scale LLMs whilst also re-\\nmaining straightforward to use. DUS consists of\\nscaling the number of layers in the base model and\\ncontinually pretraining the scaled model. Unlike\\n(Komatsuzaki et al., 2022), DUS does not scale\\nthe model using MoE and rather use a depthwise\\nscaling method analogous to Tan and Le (2019)\\nwhich is adapted for the LLM architecture. Thus,\\nthere are no additional modules or dynamism as\\nwith MoE, making DUS immediately compatible\\nwith easy-to-use LLM frameworks such as Hug-\\ngingFace (Wolf et al., 2019) with no changes to\\nthe training or inference framework for maximal\\nefficiency. Furthermore, DUS is applicable to all\\ntransformer architectures, opening up new gate-\\nways to effectively and efficiently scale-up LLMs\\nin a simple manner. Using DUS, we release SO-\\nLAR 10.7B, an LLM with 10.7 billion parameters,\\nthat outperforms existing models like Llama 2 (Tou-\\nvron et al., 2023) and Mistral 7B (Jiang et al., 2023)\\nin various benchmarks. We have also developed SOLAR 10.7B-Instruct,\\na variant fine-tuned for tasks requiring strict adher-\\nence to complex instructions. It significantly out-\\nperforms the Mixtral-8x7B-Instruct model across\\nvarious evaluation metrics, evidencing an advanced\\nproficiency that exceeds the capabilities of even\\nlarger models in terms of benchmark performance. * Equal Contribution 1 Corresponding Author\\nhttps : / /huggingface.co/upstage/\\nSOLAR-1 0 · 7B-v1 . 0 By releasing SOLAR 10.7B under the Apache\\n2.0 license, we aim to promote collaboration and in-\\nnovation in NLP. This open-source approach allows 2024\\nApr\\n4\\n[cs.CL]\\narxiv:2...117.7.13' metadata={'page': 1, 'type': 'text', 'split': 'page'}\n",
+      "page_content=\"Step 1-1 Step 1-2\\nOutput Output Output\\nOutput Output Output\\n24 Layers 24Layers\\nMerge\\n8Layers\\n---- 48 Layers\\nCopy\\n8 Layers Continued\\n32Layers 32Layers\\nPretraining\\n24Layers\\n24 Layers Input\\nInput Input Input Input Input\\nStep 1. Depthwise Scaling Step2. Continued Pretraining Figure 1: Depth up-scaling for the case with n = 32, s = 48, and m = 8. Depth up-scaling is achieved through a\\ndual-stage process of depthwise scaling followed by continued pretraining. for wider access and application of these models\\nby researchers and developers globally. 2 Depth Up-Scaling To efficiently scale-up LLMs, we aim to utilize pre-\\ntrained weights of base models to scale up to larger\\nLLMs (Komatsuzaki et al., 2022). While exist-\\ning methods such as Komatsuzaki et al. (2022) use\\nMoE (Shazeer et al., 2017) to scale-up the model ar-\\nchitecture, we opt for a different depthwise scaling\\nstrategy inspired by Tan and Le (2019). We then\\ncontinually pretrain the scaled model as just scaling\\nthe model without further pretraining degrades the\\nperformance. Base model. Any n-layer transformer architec-\\nture can be used but we select the 32-layer Llama\\n2 architecture as our base model. We initialize the\\nLlama 2 architecture with pretrained weights from\\nMistral 7B, as it is one of the top performers com-\\npatible with the Llama 2 architecture. By adopting\\nthe Llama 2 architecture for our base model, we\\naim to leverage the vast pool of community re-\\nsources while introducing novel modifications to\\nfurther enhance its capabilities. Depthwise scaling. From the base model with n\\nlayers, we set the target layer count s for the scaled\\nmodel, which is largely dictated by the available\\nhardware. With the above, the depthwise scaling process\\nis as follows. The base model with n layers is\\nduplicated for subsequent modification. Then, we\\nremove the final m layers from the original model\\nand the initial m layers from its duplicate, thus\\nforming two distinct models with n - m layers.\\nThese two models are concatenated to form a scaled\\nmodel with s = 2· (n-m) layers. Note that n = 32\\nfrom our base model and we set s = 48 considering our hardware constraints and the efficiency of the\\nscaled model, i.e., fitting between 7 and 13 billion\\nparameters. Naturally, this leads to the removal of\\nm = 8 layers. The depthwise scaling process with\\nn = 32, s = 48, and m = 8 is depicted in 'Step 1:\\nDepthwise Scaling' of Fig. 1. We note that a method in the community that also\\n2 'Step 1:\\nscale the model in the same manner as\\nDepthwise Scaling' of Fig. 1 has been concurrently\\ndeveloped. Continued pretraining. The performance of the\\ndepthwise scaled model initially drops below that\\nof the base LLM. Thus, we additionally apply\\nthe continued pretraining step as shown in 'Step\\n2: Continued Pretraining' of Fig. 1. Experimen-\\ntally, we observe rapid performance recovery of\\nthe scaled model during continued pretraining, a\\nphenomenon also observed in Komatsuzaki et al.\\n(2022). We consider that the particular way of\\ndepthwise scaling has isolated the heterogeneity\\nin the scaled model which allowed for this fast\\nperformance recovery. Delving deeper into the heterogeneity of the\\nscaled model, a simpler alternative to depthwise\\nscaling could be to just repeat its layers once more,\\ni.e., from n to 2n layers. Then, the 'layer distance',\\nor the difference in the layer indices in the base\\nmodel, is only bigger than 1 where layers n and\\nn + 1 are connected, i.e., at the seam. However, this results in maximum layer distance\\nat the seam, which may be too significant of a\\ndiscrepancy for continued pretraining to quickly\\nresolve. Instead, depthwise scaling sacrifices the\\n2m middle layers, thereby reducing the discrep-\\nancy at the seam and making it easier for continued 2https : / /huggingface · co/Undi 95/\\nMistral-11B-v0 · 1\" metadata={'page': 2, 'type': 'text', 'split': 'page'}\n",
+      "page_content=\"Properties Instruction Training Datasets Alignment\\n Alpaca-GPT4 OpenOrca Synth. Math-Instruct Orca DPO Pairs Ultrafeedback Cleaned Synth. Math-Alignment\\n Total # Samples 52K 2.91M 126K 12.9K 60.8K 126K\\n Maximum # Samples Used 52K 100K 52K 12.9K 60.8K 20.1K\\n Open Source O O X O O Table 1: Training datasets used for the instruction and alignment tuning stages, respectively. For the instruction\\ntuning process, we utilized the Alpaca-GPT4 (Peng et al., 2023), OpenOrca (Mukherjee et al., 2023), and Synth.\\nMath-Instruct datasets, while for the alignment tuning, we employed the Orca DPO Pairs (Intel, 2023), Ultrafeedback\\nCleaned (Cui et al., 2023; Ivison et al., 2023), and Synth. Math-Alignment datasets. The 'Total # Samples indicates\\nthe total number of samples in the entire dataset. The 'Maximum # Samples Used' indicates the actual maximum\\nnumber of samples that were used in training, which could be lower than the total number of samples in a given\\ndataset. 'Open Source' indicates whether the dataset is open-sourced. pretraining to quickly recover performance. We\\nattribute the success of DUS to reducing such dis-\\ncrepancies in both the depthwise scaling and the\\ncontinued pretraining steps. We also hypothesize\\nthat other methods of depthwise scaling could also\\nwork for DUS, as long as the discrepancy in the\\nscaled model is sufficiently contained before the\\ncontinued pretraining step. Comparison to other up-scaling methods. Un-\\nlike Komatsuzaki et al. (2022), depthwise scaled\\nmodels do not require additional modules like gat-\\ning networks or dynamic expert selection. Conse-\\nquently, scaled models in DUS do not necessitate\\na distinct training framework for optimal training\\nefficiency, nor do they require specialized CUDA\\nkernels for fast inference. A DUS model can seam-\\nlessly integrate into existing training and inference\\nframeworks while maintaining high efficiency. 3 Training Details After DUS, including continued pretraining, we\\nperform fine-tuning of SOLAR 10.7B in two stages:\\n1) instruction tuning and 2) alignment tuning. Instruction tuning. In the instruction tuning\\nstage, the model is trained to follow instructions in\\na QA format (Zhang et al., 2023). We mostly use\\nopen-source datasets but also synthesize a math QA\\ndataset to enhance the model's mathematical capa-\\nbilities. A rundown of how we crafted the dataset is\\nas follows. First, seed math data are collected from\\nthe Math (Hendrycks et al., 2021) dataset only, to\\navoid contamination with commonly used bench-\\nmark datasets such as GSM8K (Cobbe et al., 2021).\\nThen, using a process similar to MetaMath (Yu\\net al., 2023), we rephrase the questions and an-\\nswers of the seed math data. We use the resulting\\nrephrased question-answer pairs as a QA dataset and call it 'Synth. Math-Instruct*. Alignment tuning. In the alignment tuning stage,\\nthe instruction-tuned model is further fine-tuned\\nto be more aligned with human or strong AI\\n(e.g., GPT4 (OpenAI, 2023)) preferences using\\nsDPO (Kim et al., 2024a), an improved version\\nof direct preference optimization (DPO) (Rafailov\\net al., 2023). Similar to the instruction tuning stage,\\nwe use mostly open-source datasets but also syn-\\nthesize a math-focused alignment dataset utilizing\\nthe 'Synth. Math-Instruct' dataset mentioned in the\\ninstruction tuning stage. The alignment data synthesis process is as\\nfollows. We take advantage of the fact that\\nthe rephrased question-answer pairs in Synth.\\nMath-Instruct data are beneficial in enhancing the\\nmodel's mathematical capabilities (see Sec. 4.3.1).\\nThus, we speculate that the rephrased answer to the\\nrephrased question is a better answer than the orig-\\ninal answer, possibly due to the interim rephrasing\\nstep. Consequently, we set the rephrased question\\nas the prompt and use the rephrased answer as the\\nchosen response and the original answer as the re-\\njected response and create the {prompt, chosen,\\nrejected} DPO tuple. We aggregate the tuples from\\nthe rephrased question-answer pairs and call the\\nresulting dataset 'Synth. Math-Alignment*. 4 Results 4.1 Experimental Details Training datasets. We present details regarding\\nour training datasets for the instruction and align-\\nment tuning stages in Tab. 1. We do not always\\nuse the entire dataset and instead subsample a set\\namount. Note that most of our training data is\\nopen-source, and the undisclosed datasets can be\\nsubstituted for open-source alternatives such as the\" metadata={'page': 3, 'type': 'text', 'split': 'page'}\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_upstage import UpstageLayoutAnalysisLoader\n",
+    "\n",
+    "file_path = \"/PATH/TO/YOUR/FILE.pdf\"\n",
+    "layzer = UpstageLayoutAnalysisLoader(file_path, split=\"page\")\n",
+    "\n",
+    "# For improved memory efficiency, consider using the lazy_load method to load documents page by page.\n",
+    "docs = layzer.load()  # or layzer.lazy_load()\n",
+    "\n",
+    "for doc in docs[:3]:\n",
+    "    print(doc)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/docs/integrations/document_transformers/cross_encoder_reranker.ipynb

@@ -82,7 +82,7 @@
     ")\n",
     "\n",
     "query = \"What is the plan for the economy?\"\n",
-    "docs = retriever.get_relevant_documents(query)\n",
+    "docs = retriever.invoke(query)\n",
     "pretty_print_docs(docs)"
    ]
   },
@@ -162,9 +162,7 @@
     "    base_compressor=compressor, base_retriever=retriever\n",
     ")\n",
     "\n",
-    "compressed_docs = compression_retriever.get_relevant_documents(\n",
-    "    \"What is the plan for the economy?\"\n",
-    ")\n",
+    "compressed_docs = compression_retriever.invoke(\"What is the plan for the economy?\")\n",
     "pretty_print_docs(compressed_docs)"
    ]
   },

docs/docs/integrations/document_transformers/jina_rerank.ipynb

@@ -0,0 +1,254 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "f6ff09ab-c736-4a18-a717-563b4e29d22d",
+   "metadata": {},
+   "source": [
+    "# Jina Reranker"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1288789a-4c30-4fc3-90c7-dd1741a2550b",
+   "metadata": {},
+   "source": [
+    "This notebook shows how to use Jina Reranker for document compression and retrieval."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a0e4d52e-3968-4f8b-9865-a886f27e5feb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install -qU langchain langchain-openai langchain-community langchain-text-splitters langchainhub\n",
+    "\n",
+    "%pip install --upgrade --quiet  faiss\n",
+    "\n",
+    "# OR  (depending on Python version)\n",
+    "\n",
+    "%pip install --upgrade --quiet  faiss_cpu"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d1fc07a6-8e01-4aa5-8ed4-ca2b0bfca70c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Helper function for printing docs\n",
+    "\n",
+    "\n",
+    "def pretty_print_docs(docs):\n",
+    "    print(\n",
+    "        f\"\\n{'-' * 100}\\n\".join(\n",
+    "            [f\"Document {i+1}:\\n\\n\" + d.page_content for i, d in enumerate(docs)]\n",
+    "        )\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d8ec4823-fdc1-4339-8a25-da598a1e2a4c",
+   "metadata": {},
+   "source": [
+    "## Set up the base vector store retriever"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9db25269-e798-496f-8fb9-2bb280735118",
+   "metadata": {},
+   "source": [
+    "Let's start by initializing a simple vector store retriever and storing the 2023 State of the Union speech (in chunks). We can set up the retriever to retrieve a high number (20) of docs."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ce01a2b5-d7f4-4902-9156-9a3a86704f40",
+   "metadata": {},
+   "source": [
+    "##### Set the Jina and OpenAI API keys"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6692d5c5-c84a-4d42-8dd8-5ce90ff56d20",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import getpass\n",
+    "import os\n",
+    "\n",
+    "os.environ[\"OPENAI_API_KEY\"] = getpass.getpass()\n",
+    "os.environ[\"JINA_API_KEY\"] = getpass.getpass()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "981159af-fa3c-4f75-adb4-1a4de1950f2f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_community.document_loaders import TextLoader\n",
+    "from langchain_community.embeddings import JinaEmbeddings\n",
+    "from langchain_community.vectorstores import FAISS\n",
+    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
+    "\n",
+    "documents = TextLoader(\n",
+    "    \"../../modules/state_of_the_union.txt\",\n",
+    ").load()\n",
+    "text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100)\n",
+    "texts = text_splitter.split_documents(documents)\n",
+    "\n",
+    "embedding = JinaEmbeddings(model_name=\"jina-embeddings-v2-base-en\")\n",
+    "retriever = FAISS.from_documents(texts, embedding).as_retriever(search_kwargs={\"k\": 20})\n",
+    "\n",
+    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+    "docs = retriever.get_relevant_documents(query)\n",
+    "pretty_print_docs(docs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b5a514b7-027a-4dd4-9cfc-63fb4d50aa66",
+   "metadata": {},
+   "source": [
+    "## Doing reranking with JinaRerank"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bdd9e0ca-d728-42cb-88ad-459fb8a56b33",
+   "metadata": {},
+   "source": [
+    "Now let's wrap our base retriever with a ContextualCompressionRetriever, using Jina Reranker as a compressor."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3000019e-cc0d-4365-91d0-72247ee4d624",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.retrievers import ContextualCompressionRetriever\n",
+    "from langchain_community.document_compressors import JinaRerank\n",
+    "\n",
+    "compressor = JinaRerank()\n",
+    "compression_retriever = ContextualCompressionRetriever(\n",
+    "    base_compressor=compressor, base_retriever=retriever\n",
+    ")\n",
+    "\n",
+    "compressed_docs = compression_retriever.get_relevant_documents(\n",
+    "    \"What did the president say about Ketanji Jackson Brown\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f314f74c-48a9-4243-8d3c-2b7f820e1e40",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pretty_print_docs(compressed_docs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "87164f04-194b-4138-8d94-f179f6f34a31",
+   "metadata": {},
+   "source": [
+    "## QA reranking with Jina Reranker"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "2b4ab60b-5a26-4cfb-9b58-3dc2d83b772b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "================================\u001b[1m System Message \u001b[0m================================\n",
+      "\n",
+      "Answer any use questions based solely on the context below:\n",
+      "\n",
+      "<context>\n",
+      "\u001b[33;1m\u001b[1;3m{context}\u001b[0m\n",
+      "</context>\n",
+      "\n",
+      "=============================\u001b[1m Messages Placeholder \u001b[0m=============================\n",
+      "\n",
+      "\u001b[33;1m\u001b[1;3m{chat_history}\u001b[0m\n",
+      "\n",
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "\u001b[33;1m\u001b[1;3m{input}\u001b[0m\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain import hub\n",
+    "from langchain.chains import create_retrieval_chain\n",
+    "from langchain.chains.combine_documents import create_stuff_documents_chain\n",
+    "\n",
+    "retrieval_qa_chat_prompt = hub.pull(\"langchain-ai/retrieval-qa-chat\")\n",
+    "retrieval_qa_chat_prompt.pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "72af3eb3-b644-4b5f-bf5f-f1dc43c96882",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\n",
+    "combine_docs_chain = create_stuff_documents_chain(llm, retrieval_qa_chat_prompt)\n",
+    "chain = create_retrieval_chain(compression_retriever, combine_docs_chain)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "126401a7-c545-4de0-92dc-e9bc1001a6ba",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain.invoke({\"input\": query})"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "poetry-venv-2",
+   "language": "python",
+   "name": "poetry-venv-2"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/docs/integrations/document_transformers/openvino_rerank.ipynb

@@ -18,7 +18,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -28,42 +28,7 @@
      "is_executing": true
     }
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
-      "To disable this warning, you can either:\n",
-      "\t- Avoid using `tokenizers` before the fork if possible\n",
-      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Note: you may need to restart the kernel to use updated packages.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
-      "To disable this warning, you can either:\n",
-      "\t- Avoid using `tokenizers` before the fork if possible\n",
-      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Note: you may need to restart the kernel to use updated packages.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%pip install --upgrade-strategy eager \"optimum[openvino,nncf]\" --quiet\n",
     "%pip install --upgrade --quiet  faiss-cpu"
@@ -385,7 +350,7 @@
     "retriever = FAISS.from_documents(texts, embedding).as_retriever(search_kwargs={\"k\": 20})\n",
     "\n",
     "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "docs = retriever.get_relevant_documents(query)\n",
+    "docs = retriever.invoke(query)\n",
     "pretty_print_docs(docs)"
    ]
   },
@@ -404,49 +369,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {
     "collapsed": false,
     "jupyter": {
      "outputs_hidden": false
     }
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Framework not specified. Using pt to export the model.\n",
-      "Using the export variant default. Available variants are:\n",
-      "    - default: The default ONNX variant.\n",
-      "Using framework PyTorch: 2.2.1+cu121\n",
-      "Overriding 1 configuration item(s)\n",
-      "\t- use_cache -> False\n",
-      "/home/ethan/intel/langchain_test/lib/python3.10/site-packages/transformers/modeling_utils.py:4193: FutureWarning: `_is_quantized_training_enabled` is going to be deprecated in transformers 4.39.0. Please use `model.hf_quantizer.is_trainable` instead\n",
-      "  warnings.warn(\n",
-      "Compiling the model to CPU ...\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[0, 16, 18, 6]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from langchain.retrievers import ContextualCompressionRetriever\n",
     "from langchain_community.document_compressors.openvino_rerank import OpenVINOReranker\n",
     "\n",
     "model_name = \"BAAI/bge-reranker-large\"\n",
     "\n",
-    "compressor = OpenVINOReranker(model_name_or_path=model_name)\n",
+    "ov_compressor = OpenVINOReranker(model_name_or_path=model_name, top_n=4)\n",
     "compression_retriever = ContextualCompressionRetriever(\n",
-    "    base_compressor=compressor, base_retriever=retriever\n",
+    "    base_compressor=ov_compressor, base_retriever=retriever\n",
     ")\n",
     "\n",
-    "compressed_docs = compression_retriever.get_relevant_documents(\n",
+    "compressed_docs = compression_retriever.invoke(\n",
     "    \"What did the president say about Ketanji Jackson Brown\"\n",
     ")\n",
     "print([doc.metadata[\"id\"] for doc in compressed_docs])"
@@ -461,7 +403,7 @@
     }
    },
    "source": [
-    "After reranking, the top 3 documents are different from the top 3 documents retrieved by the base retriever."
+    "After reranking, the top 4 documents are different from the top 4 documents retrieved by the base retriever."
    ]
   },
   {
@@ -532,37 +474,13 @@
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Framework not specified. Using pt to export the model.\n",
-      "Using the export variant default. Available variants are:\n",
-      "    - default: The default ONNX variant.\n",
-      "Using framework PyTorch: 2.2.1+cu121\n",
-      "Overriding 1 configuration item(s)\n",
-      "\t- use_cache -> False\n",
-      "/home/ethan/intel/langchain_test/lib/python3.10/site-packages/transformers/modeling_utils.py:4193: FutureWarning: `_is_quantized_training_enabled` is going to be deprecated in transformers 4.39.0. Please use `model.hf_quantizer.is_trainable` instead\n",
-      "  warnings.warn(\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from pathlib import Path\n",
     "\n",
     "ov_model_dir = \"bge-reranker-large-ov\"\n",
     "if not Path(ov_model_dir).exists():\n",
-    "    from optimum.intel.openvino import OVModelForSequenceClassification\n",
-    "    from transformers import AutoTokenizer\n",
-    "\n",
-    "    ov_model = OVModelForSequenceClassification.from_pretrained(\n",
-    "        model_name, compile=False, export=True\n",
-    "    )\n",
-    "    tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
-    "    ov_model.half()\n",
-    "    ov_model.save_pretrained(ov_model_dir)\n",
-    "    tokenizer.save_pretrained(ov_model_dir)"
+    "    ov_compressor.save_model(ov_model_dir)"
    ]
   },
   {
@@ -579,7 +497,7 @@
     }
    ],
    "source": [
-    "compressor = OpenVINOReranker(model_name_or_path=ov_model_dir)"
+    "ov_compressor = OpenVINOReranker(model_name_or_path=ov_model_dir)"
    ]
   },
   {
@@ -594,7 +512,7 @@
     "\n",
     "* [OpenVINO Get Started Guide](https://www.intel.com/content/www/us/en/content-details/819067/openvino-get-started-guide.html).\n",
     "\n",
-    "* [RAG Notebook with LangChain](https://github.com/openvinotoolkit/openvino_notebooks/blob/latest/notebooks/llm-chatbot/rag-chatbot.ipynb)."
+    "* [RAG Notebook with LangChain](https://github.com/openvinotoolkit/openvino_notebooks/tree/latest/notebooks/llm-rag-langchain)."
    ]
   }
  ],

docs/docs/integrations/document_transformers/voyageai-reranker.ipynb

@@ -84,7 +84,13 @@
    },
    "source": [
     "## Set up the base vector store retriever\n",
-    "Let's start by initializing a simple vector store retriever and storing the 2023 State of the Union speech (in chunks). We can set up the retriever to retrieve a high number (20) of docs."
+    "Let's start by initializing a simple vector store retriever and storing the 2023 State of the Union speech (in chunks). We can set up the retriever to retrieve a high number (20) of docs. You can use any of the following Embeddings models: ([source](https://docs.voyageai.com/docs/embeddings)):\n",
+    "\n",
+    "- `voyage-large-2` (default)\n",
+    "- `voyage-code-2`\n",
+    "- `voyage-2`\n",
+    "- `voyage-law-2`\n",
+    "- `voyage-lite-02-instruct`"
    ]
   },
   {
@@ -316,11 +322,11 @@
     "text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100)\n",
     "texts = text_splitter.split_documents(documents)\n",
     "retriever = FAISS.from_documents(\n",
-    "    texts, VoyageAIEmbeddings(model=\"voyage-2\")\n",
+    "    texts, VoyageAIEmbeddings(model=\"voyage-law-2\")\n",
     ").as_retriever(search_kwargs={\"k\": 20})\n",
     "\n",
     "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "docs = retriever.get_relevant_documents(query)\n",
+    "docs = retriever.invoke(query)\n",
     "pretty_print_docs(docs)"
    ]
   },
@@ -382,7 +388,7 @@
     "    base_compressor=compressor, base_retriever=retriever\n",
     ")\n",
     "\n",
-    "compressed_docs = compression_retriever.get_relevant_documents(\n",
+    "compressed_docs = compression_retriever.invoke(\n",
     "    \"What did the president say about Ketanji Jackson Brown\"\n",
     ")\n",
     "pretty_print_docs(compressed_docs)"

docs/docs/integrations/graphs/amazon_neptune_sparql.ipynb

@@ -118,25 +118,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install --upgrade --force-reinstall langchain"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!pip install --upgrade --force-reinstall langchain-core"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!pip install --upgrade --force-reinstall langchain-community"
+    "!pip install --upgrade --quiet langchain langchain-community langchain-aws"
    ]
   },
   {
@@ -264,7 +246,7 @@
    "source": [
     "import boto3\n",
     "from langchain.chains.graph_qa.neptune_sparql import NeptuneSparqlQAChain\n",
-    "from langchain_community.chat_models import BedrockChat\n",
+    "from langchain_aws import ChatBedrock\n",
     "from langchain_community.graphs import NeptuneRdfGraph\n",
     "\n",
     "host = \"<your host>\"\n",
@@ -279,7 +261,7 @@
     "\n",
     "MODEL_ID = \"anthropic.claude-v2\"\n",
     "bedrock_client = boto3.client(\"bedrock-runtime\")\n",
-    "llm = BedrockChat(model_id=MODEL_ID, client=bedrock_client)\n",
+    "llm = ChatBedrock(model_id=MODEL_ID, client=bedrock_client)\n",
     "\n",
     "chain = NeptuneSparqlQAChain.from_llm(\n",
     "    llm=llm,\n",

docs/docs/integrations/graphs/apache_age.ipynb

@@ -0,0 +1,689 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "c94240f5",
+   "metadata": {},
+   "source": [
+    "# Apache AGE\n",
+    "\n",
+    ">[Apache AGE](https://age.apache.org/) is a PostgreSQL extension that provides graph database functionality. AGE is an acronym for A Graph Extension, and is inspired by Bitnine’s fork of PostgreSQL 10, AgensGraph, which is a multi-model database. The goal of the project is to create single storage that can handle both relational and graph model data so that users can use standard ANSI SQL along with openCypher, the Graph query language. The data elements `Apache AGE` stores are nodes, edges connecting them, and attributes of nodes and edges.\n",
+    "\n",
+    ">This notebook shows how to use LLMs to provide a natural language interface to a graph database you can query with the `Cypher` query language.\n",
+    "\n",
+    ">[Cypher](https://en.wikipedia.org/wiki/Cypher_(query_language)) is a declarative graph query language that allows for expressive and efficient data querying in a property graph.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dbc0ee68",
+   "metadata": {},
+   "source": [
+    "## Setting up\n",
+    "\n",
+    "You will need to have a running `Postgre` instance with the AGE extension installed. One option for testing is to run a docker container using the official AGE docker image.\n",
+    "You can run a local docker container by running the executing the following script:\n",
+    "\n",
+    "```\n",
+    "docker run \\\n",
+    "    --name age  \\\n",
+    "    -p 5432:5432 \\\n",
+    "    -e POSTGRES_USER=postgresUser \\\n",
+    "    -e POSTGRES_PASSWORD=postgresPW \\\n",
+    "    -e POSTGRES_DB=postgresDB \\\n",
+    "    -d \\\n",
+    "    apache/age\n",
+    "```\n",
+    "\n",
+    "Additional instructions on running in docker can be found [here](https://hub.docker.com/r/apache/age)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "62812aad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains import GraphCypherQAChain\n",
+    "from langchain_community.graphs.age_graph import AGEGraph\n",
+    "from langchain_openai import ChatOpenAI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "0928915d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "conf = {\n",
+    "    \"database\": \"postgresDB\",\n",
+    "    \"user\": \"postgresUser\",\n",
+    "    \"password\": \"postgresPW\",\n",
+    "    \"host\": \"localhost\",\n",
+    "    \"port\": 5432,\n",
+    "}\n",
+    "\n",
+    "graph = AGEGraph(graph_name=\"age_test\", conf=conf)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "995ea9b9",
+   "metadata": {},
+   "source": [
+    "## Seeding the database\n",
+    "\n",
+    "Assuming your database is empty, you can populate it using Cypher query language. The following Cypher statement is idempotent, which means the database information will be the same if you run it one or multiple times."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "fedd26b9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "graph.query(\n",
+    "    \"\"\"\n",
+    "MERGE (m:Movie {name:\"Top Gun\"})\n",
+    "WITH m\n",
+    "UNWIND [\"Tom Cruise\", \"Val Kilmer\", \"Anthony Edwards\", \"Meg Ryan\"] AS actor\n",
+    "MERGE (a:Actor {name:actor})\n",
+    "MERGE (a)-[:ACTED_IN]->(m)\n",
+    "\"\"\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58c1a8ea",
+   "metadata": {},
+   "source": [
+    "## Refresh graph schema information\n",
+    "If the schema of database changes, you can refresh the schema information needed to generate Cypher statements."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "4e3de44f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "graph.refresh_schema()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "1fe76ccd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "        Node properties are the following:\n",
+      "        [{'properties': [{'property': 'name', 'type': 'STRING'}], 'labels': 'Actor'}, {'properties': [{'property': 'property_a', 'type': 'STRING'}], 'labels': 'LabelA'}, {'properties': [], 'labels': 'LabelB'}, {'properties': [], 'labels': 'LabelC'}, {'properties': [{'property': 'name', 'type': 'STRING'}], 'labels': 'Movie'}]\n",
+      "        Relationship properties are the following:\n",
+      "        [{'properties': [], 'type': 'ACTED_IN'}, {'properties': [{'property': 'rel_prop', 'type': 'STRING'}], 'type': 'REL_TYPE'}]\n",
+      "        The relationships are the following:\n",
+      "        ['(:`Actor`)-[:`ACTED_IN`]->(:`Movie`)', '(:`LabelA`)-[:`REL_TYPE`]->(:`LabelB`)', '(:`LabelA`)-[:`REL_TYPE`]->(:`LabelC`)']\n",
+      "        \n"
+     ]
+    }
+   ],
+   "source": [
+    "print(graph.schema)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "68a3c677",
+   "metadata": {},
+   "source": [
+    "## Querying the graph\n",
+    "\n",
+    "We can now use the graph cypher QA chain to ask question of the graph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "7476ce98",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = GraphCypherQAChain.from_llm(\n",
+    "    ChatOpenAI(temperature=0), graph=graph, verbose=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "ef8ee27b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new GraphCypherQAChain chain...\u001b[0m\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generated Cypher:\n",
+      "\u001b[32;1m\u001b[1;3mMATCH (a:Actor)-[:ACTED_IN]->(m:Movie)\n",
+      "WHERE m.name = 'Top Gun'\n",
+      "RETURN a.name\u001b[0m\n",
+      "Full Context:\n",
+      "\u001b[32;1m\u001b[1;3m[{'name': 'Tom Cruise'}, {'name': 'Val Kilmer'}, {'name': 'Anthony Edwards'}, {'name': 'Meg Ryan'}]\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'query': 'Who played in Top Gun?',\n",
+       " 'result': 'Tom Cruise, Val Kilmer, Anthony Edwards, Meg Ryan played in Top Gun.'}"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke(\"Who played in Top Gun?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d28c4df",
+   "metadata": {},
+   "source": [
+    "## Limit the number of results\n",
+    "You can limit the number of results from the Cypher QA Chain using the `top_k` parameter.\n",
+    "The default is 10."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "df230946",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = GraphCypherQAChain.from_llm(\n",
+    "    ChatOpenAI(temperature=0), graph=graph, verbose=True, top_k=2\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "3f1600ee",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new GraphCypherQAChain chain...\u001b[0m\n",
+      "Generated Cypher:\n",
+      "\u001b[32;1m\u001b[1;3mMATCH (a:Actor)-[:ACTED_IN]->(m:Movie {name: 'Top Gun'})\n",
+      "RETURN a.name\u001b[0m\n",
+      "Full Context:\n",
+      "\u001b[32;1m\u001b[1;3m[{'name': 'Tom Cruise'}, {'name': 'Val Kilmer'}]\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'query': 'Who played in Top Gun?',\n",
+       " 'result': 'Tom Cruise, Val Kilmer played in Top Gun.'}"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke(\"Who played in Top Gun?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "88c16206",
+   "metadata": {},
+   "source": [
+    "## Return intermediate results\n",
+    "You can return intermediate steps from the Cypher QA Chain using the `return_intermediate_steps` parameter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "e412f36b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = GraphCypherQAChain.from_llm(\n",
+    "    ChatOpenAI(temperature=0), graph=graph, verbose=True, return_intermediate_steps=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "4f4699dc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new GraphCypherQAChain chain...\u001b[0m\n",
+      "Generated Cypher:\n",
+      "\u001b[32;1m\u001b[1;3mMATCH (a:Actor)-[:ACTED_IN]->(m:Movie)\n",
+      "WHERE m.name = 'Top Gun'\n",
+      "RETURN a.name\u001b[0m\n",
+      "Full Context:\n",
+      "\u001b[32;1m\u001b[1;3m[{'name': 'Tom Cruise'}, {'name': 'Val Kilmer'}, {'name': 'Anthony Edwards'}, {'name': 'Meg Ryan'}]\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "Intermediate steps: [{'query': \"MATCH (a:Actor)-[:ACTED_IN]->(m:Movie)\\nWHERE m.name = 'Top Gun'\\nRETURN a.name\"}, {'context': [{'name': 'Tom Cruise'}, {'name': 'Val Kilmer'}, {'name': 'Anthony Edwards'}, {'name': 'Meg Ryan'}]}]\n",
+      "Final answer: Tom Cruise, Val Kilmer, Anthony Edwards, Meg Ryan played in Top Gun.\n"
+     ]
+    }
+   ],
+   "source": [
+    "result = chain(\"Who played in Top Gun?\")\n",
+    "print(f\"Intermediate steps: {result['intermediate_steps']}\")\n",
+    "print(f\"Final answer: {result['result']}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d6e1b054",
+   "metadata": {},
+   "source": [
+    "## Return direct results\n",
+    "You can return direct results from the Cypher QA Chain using the `return_direct` parameter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "2d3acf10",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = GraphCypherQAChain.from_llm(\n",
+    "    ChatOpenAI(temperature=0), graph=graph, verbose=True, return_direct=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "b0a9d143",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new GraphCypherQAChain chain...\u001b[0m\n",
+      "Generated Cypher:\n",
+      "\u001b[32;1m\u001b[1;3mMATCH (a:Actor)-[:ACTED_IN]->(m:Movie {name: 'Top Gun'})\n",
+      "RETURN a.name\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'query': 'Who played in Top Gun?',\n",
+       " 'result': [{'name': 'Tom Cruise'},\n",
+       "  {'name': 'Val Kilmer'},\n",
+       "  {'name': 'Anthony Edwards'},\n",
+       "  {'name': 'Meg Ryan'}]}"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke(\"Who played in Top Gun?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f01dfb72-24ec-4ae7-883a-ee6646889b59",
+   "metadata": {},
+   "source": [
+    "## Add examples in the Cypher generation prompt\n",
+    "You can define the Cypher statement you want the LLM to generate for particular questions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "59baeb88-adfa-4c26-8334-fcbff3a98efb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.prompts.prompt import PromptTemplate\n",
+    "\n",
+    "CYPHER_GENERATION_TEMPLATE = \"\"\"Task:Generate Cypher statement to query a graph database.\n",
+    "Instructions:\n",
+    "Use only the provided relationship types and properties in the schema.\n",
+    "Do not use any other relationship types or properties that are not provided.\n",
+    "Schema:\n",
+    "{schema}\n",
+    "Note: Do not include any explanations or apologies in your responses.\n",
+    "Do not respond to any questions that might ask anything else than for you to construct a Cypher statement.\n",
+    "Do not include any text except the generated Cypher statement.\n",
+    "Examples: Here are a few examples of generated Cypher statements for particular questions:\n",
+    "# How many people played in Top Gun?\n",
+    "MATCH (m:Movie {{title:\"Top Gun\"}})<-[:ACTED_IN]-()\n",
+    "RETURN count(*) AS numberOfActors\n",
+    "\n",
+    "The question is:\n",
+    "{question}\"\"\"\n",
+    "\n",
+    "CYPHER_GENERATION_PROMPT = PromptTemplate(\n",
+    "    input_variables=[\"schema\", \"question\"], template=CYPHER_GENERATION_TEMPLATE\n",
+    ")\n",
+    "\n",
+    "chain = GraphCypherQAChain.from_llm(\n",
+    "    ChatOpenAI(temperature=0),\n",
+    "    graph=graph,\n",
+    "    verbose=True,\n",
+    "    cypher_prompt=CYPHER_GENERATION_PROMPT,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "47c64027-cf42-493a-9c76-2d10ba753728",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new GraphCypherQAChain chain...\u001b[0m\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generated Cypher:\n",
+      "\u001b[32;1m\u001b[1;3mMATCH (:Movie {name:\"Top Gun\"})<-[:ACTED_IN]-(:Actor)\n",
+      "RETURN count(*) AS numberOfActors\u001b[0m\n",
+      "Full Context:\n",
+      "\u001b[32;1m\u001b[1;3m[{'numberofactors': 4}]\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'query': 'How many people played in Top Gun?',\n",
+       " 'result': \"I don't know the answer.\"}"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke(\"How many people played in Top Gun?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3e721cad-aa87-4526-9231-2dfc0e365939",
+   "metadata": {},
+   "source": [
+    "## Use separate LLMs for Cypher and answer generation\n",
+    "You can use the `cypher_llm` and `qa_llm` parameters to define different llms"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "6f9becc2-f579-45bf-9b50-2ce02bde92da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = GraphCypherQAChain.from_llm(\n",
+    "    graph=graph,\n",
+    "    cypher_llm=ChatOpenAI(temperature=0, model=\"gpt-3.5-turbo\"),\n",
+    "    qa_llm=ChatOpenAI(temperature=0, model=\"gpt-3.5-turbo-16k\"),\n",
+    "    verbose=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "ff18e3e3-3402-4683-aec4-a19898f23ca1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new GraphCypherQAChain chain...\u001b[0m\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generated Cypher:\n",
+      "\u001b[32;1m\u001b[1;3mMATCH (a:Actor)-[:ACTED_IN]->(m:Movie)\n",
+      "WHERE m.name = 'Top Gun'\n",
+      "RETURN a.name\u001b[0m\n",
+      "Full Context:\n",
+      "\u001b[32;1m\u001b[1;3m[{'name': 'Tom Cruise'}, {'name': 'Val Kilmer'}, {'name': 'Anthony Edwards'}, {'name': 'Meg Ryan'}]\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'query': 'Who played in Top Gun?',\n",
+       " 'result': 'Tom Cruise, Val Kilmer, Anthony Edwards, and Meg Ryan played in Top Gun.'}"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke(\"Who played in Top Gun?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eefea16b-508f-4552-8942-9d5063ed7d37",
+   "metadata": {},
+   "source": [
+    "## Ignore specified node and relationship types\n",
+    "\n",
+    "You can use `include_types` or `exclude_types` to ignore parts of the graph schema when generating Cypher statements."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "a20fa21e-fb85-41c4-aac0-53fb25e34604",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = GraphCypherQAChain.from_llm(\n",
+    "    graph=graph,\n",
+    "    cypher_llm=ChatOpenAI(temperature=0, model=\"gpt-3.5-turbo\"),\n",
+    "    qa_llm=ChatOpenAI(temperature=0, model=\"gpt-3.5-turbo-16k\"),\n",
+    "    verbose=True,\n",
+    "    exclude_types=[\"Movie\"],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "3ad7f6b8-543e-46e4-a3b2-40fa3e66e895",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Node properties are the following:\n",
+      "Actor {name: STRING},LabelA {property_a: STRING},LabelB {},LabelC {}\n",
+      "Relationship properties are the following:\n",
+      "ACTED_IN {},REL_TYPE {rel_prop: STRING}\n",
+      "The relationships are the following:\n",
+      "(:LabelA)-[:REL_TYPE]->(:LabelB),(:LabelA)-[:REL_TYPE]->(:LabelC)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Inspect graph schema\n",
+    "print(chain.graph_schema)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f0202e88-d700-40ed-aef9-0c969c7bf951",
+   "metadata": {},
+   "source": [
+    "## Validate generated Cypher statements\n",
+    "You can use the `validate_cypher` parameter to validate and correct relationship directions in generated Cypher statements"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "53665d03-7afd-433c-bdd5-750127bfb152",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = GraphCypherQAChain.from_llm(\n",
+    "    llm=ChatOpenAI(temperature=0, model=\"gpt-3.5-turbo\"),\n",
+    "    graph=graph,\n",
+    "    verbose=True,\n",
+    "    validate_cypher=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "19e1a591-9c10-4d7b-aa36-a5e1b778a97b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new GraphCypherQAChain chain...\u001b[0m\n",
+      "Generated Cypher:\n",
+      "\u001b[32;1m\u001b[1;3mMATCH (a:Actor)-[:ACTED_IN]->(m:Movie)\n",
+      "WHERE m.name = 'Top Gun'\n",
+      "RETURN a.name\u001b[0m\n",
+      "Full Context:\n",
+      "\u001b[32;1m\u001b[1;3m[{'name': 'Tom Cruise'}, {'name': 'Val Kilmer'}, {'name': 'Anthony Edwards'}, {'name': 'Meg Ryan'}]\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'query': 'Who played in Top Gun?',\n",
+       " 'result': 'Tom Cruise, Val Kilmer, Anthony Edwards, Meg Ryan played in Top Gun.'}"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke(\"Who played in Top Gun?\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/docs/integrations/graphs/memgraph.ipynb

@@ -19,26 +19,22 @@
     "\n",
     "To complete this tutorial, you will need [Docker](https://www.docker.com/get-started/) and [Python 3.x](https://www.python.org/) installed.\n",
     "\n",
-    "Ensure you have a running `Memgraph` instance. You can download and run it in a local Docker container by executing the following script:\n",
+    "Ensure you have a running Memgraph instance. To quickly run Memgraph Platform (Memgraph database + MAGE library + Memgraph Lab) for the first time, do the following:\n",
+    "\n",
+    "On Linux/MacOS:\n",
     "```\n",
-    "docker run \\\n",
-    "    -it \\\n",
-    "    -p 7687:7687 \\\n",
-    "    -p 7444:7444 \\\n",
-    "    -p 3000:3000 \\\n",
-    "    -e MEMGRAPH=\"--bolt-server-name-for-init=Neo4j/\" \\\n",
-    "    -v mg_lib:/var/lib/memgraph memgraph/memgraph-platform\n",
+    "curl https://install.memgraph.com | sh\n",
     "```\n",
     "\n",
-    "You will need to wait a few seconds for the database to start. If the process is completed successfully, you should see something like this:\n",
+    "On Windows:\n",
     "```\n",
-    "mgconsole X.X\n",
-    "Connected to 'memgraph://127.0.0.1:7687'\n",
-    "Type :help for shell usage\n",
-    "Quit the shell by typing Ctrl-D(eof) or :quit\n",
-    "memgraph>\n",
+    "iwr https://windows.memgraph.com | iex\n",
     "```\n",
     "\n",
+    "Both commands run a script that downloads a Docker Compose file to your system, builds and starts `memgraph-mage` and `memgraph-lab` Docker services in two separate containers. \n",
+    "\n",
+    "Read more about the installation process on [Memgraph documentation](https://memgraph.com/docs/getting-started/install-memgraph).\n",
+    "\n",
     "Now you can start playing with `Memgraph`!"
    ]
   },
@@ -79,8 +75,8 @@
     "\n",
     "from gqlalchemy import Memgraph\n",
     "from langchain.chains import GraphCypherQAChain\n",
-    "from langchain.prompts import PromptTemplate\n",
     "from langchain_community.graphs import MemgraphGraph\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "from langchain_openai import ChatOpenAI"
    ]
   },
@@ -89,7 +85,7 @@
    "id": "95ba37a4",
    "metadata": {},
    "source": [
-    "We're utilizing the Python library [GQLAlchemy](https://github.com/memgraph/gqlalchemy) to establish a connection between our Memgraph database and Python script. To execute queries, we can set up a Memgraph instance as follows:"
+    "We're utilizing the Python library [GQLAlchemy](https://github.com/memgraph/gqlalchemy) to establish a connection between our Memgraph database and Python script. You can establish the connection to a running Memgraph instance with the Neo4j driver as well, since it's compatible with Memgraph. To execute queries with GQLAlchemy, we can set up a Memgraph instance as follows:"
    ]
   },
   {

docs/docs/integrations/graphs/neo4j_cypher.ipynb

@@ -389,7 +389,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts.prompt import PromptTemplate\n",
+    "from langchain_core.prompts.prompt import PromptTemplate\n",
     "\n",
     "CYPHER_GENERATION_TEMPLATE = \"\"\"Task:Generate Cypher statement to query a graph database.\n",
     "Instructions:\n",

docs/docs/integrations/graphs/tigergraph.mdx

@@ -0,0 +1,37 @@
+# TigerGraph
+
+>[TigerGraph](https://www.tigergraph.com/tigergraph-db/) is a natively distributed and high-performance graph database.
+> The storage of data in a graph format of vertices and edges leads to rich relationships, 
+> ideal for grouding LLM responses.
+ 
+A big example of the `TigerGraph` and `LangChain` integration [presented here](https://github.com/tigergraph/graph-ml-notebooks/blob/main/applications/large_language_models/TigerGraph_LangChain_Demo.ipynb).
+
+## Installation and Setup
+
+Follow instructions [how to connect to the `TigerGraph` database](https://docs.tigergraph.com/pytigergraph/current/getting-started/connection).
+
+Install the Python SDK:
+
+```bash
+pip install pyTigerGraph
+```
+
+## Example
+
+To utilize the `TigerGraph InquiryAI` functionality, you can import `TigerGraph` from `langchain_community.graphs`.
+
+```python
+import pyTigerGraph as tg
+
+conn = tg.TigerGraphConnection(host="DATABASE_HOST_HERE", graphname="GRAPH_NAME_HERE", username="USERNAME_HERE", password="PASSWORD_HERE")
+
+### ==== CONFIGURE INQUIRYAI HOST ====
+conn.ai.configureInquiryAIHost("INQUIRYAI_HOST_HERE")
+
+from langchain_community.graphs import TigerGraph
+
+graph = TigerGraph(conn)
+result = graph.query("How many servers are there?")
+print(result)
+```
+