langchain 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

langchain/document_transformers/__init__.py

@@ -14,6 +14,7 @@
 
     Document
 """  # noqa: E501
+
 from typing import TYPE_CHECKING, Any
 
 from langchain._api import create_importer

langchain/embeddings/__init__.py

@@ -10,7 +10,6 @@ from different APIs and services.
     Embeddings --> <name>Embeddings  # Examples: OpenAIEmbeddings, HuggingFaceEmbeddings
 """
 
-
 import logging
 from typing import TYPE_CHECKING, Any
 

langchain/evaluation/__init__.py

@@ -38,7 +38,7 @@ name of the dataset to load.
 - Comparing the output of two models: :class:`PairwiseStringEvalChain <langchain.evaluation.comparison.eval_chain.PairwiseStringEvalChain>` or :class:`LabeledPairwiseStringEvalChain <langchain.evaluation.comparison.eval_chain.LabeledPairwiseStringEvalChain>` when there is additionally a reference label.
 - Judging the efficacy of an agent's tool usage: :class:`TrajectoryEvalChain <langchain.evaluation.agents.trajectory_eval_chain.TrajectoryEvalChain>`
 - Checking whether an output complies with a set of criteria: :class:`CriteriaEvalChain <langchain.evaluation.criteria.eval_chain.CriteriaEvalChain>` or :class:`LabeledCriteriaEvalChain <langchain.evaluation.criteria.eval_chain.LabeledCriteriaEvalChain>` when there is additionally a reference label.
-- Computing semantic difference between a prediction and reference: :class:`EmbeddingDistanceEvalChain <langchain.evaluation.embedding_distance.base.EmbeddingDistanceEvalChain>` or between two predictions: :class:`PairwiseEmbeddingDistanceEvalChain <langchain.evaluation.embedding_distance.base.PairwiseEmbeddingDistanceEvalChain>` 
+- Computing semantic difference between a prediction and reference: :class:`EmbeddingDistanceEvalChain <langchain.evaluation.embedding_distance.base.EmbeddingDistanceEvalChain>` or between two predictions: :class:`PairwiseEmbeddingDistanceEvalChain <langchain.evaluation.embedding_distance.base.PairwiseEmbeddingDistanceEvalChain>`
 - Measuring the string distance between a prediction and reference :class:`StringDistanceEvalChain <langchain.evaluation.string_distance.base.StringDistanceEvalChain>` or between two predictions :class:`PairwiseStringDistanceEvalChain <langchain.evaluation.string_distance.base.PairwiseStringDistanceEvalChain>`
 
 **Low-level API**
@@ -52,6 +52,7 @@ These evaluators implement one of the following interfaces:
 These interfaces enable easier composability and usage within a higher level evaluation framework.
 
 """  # noqa: E501
+
 from langchain.evaluation.agents import TrajectoryEvalChain
 from langchain.evaluation.comparison import (
     LabeledPairwiseStringEvalChain,

langchain/evaluation/agents/__init__.py

@@ -1,4 +1,5 @@
 """Chains for evaluating ReAct style agents."""
+
 from langchain.evaluation.agents.trajectory_eval_chain import TrajectoryEvalChain
 
 __all__ = ["TrajectoryEvalChain"]

langchain/evaluation/agents/trajectory_eval_prompt.py

@@ -1,4 +1,5 @@
 """Prompt for trajectory evaluation chain."""
+
 # flake8: noqa
 from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
 

langchain/evaluation/comparison/__init__.py

@@ -27,6 +27,7 @@ Example:
     # .     " by explaining what the formula means.\\n[[B]]"
     # }
 """
+
 from langchain.evaluation.comparison.eval_chain import (
     LabeledPairwiseStringEvalChain,
     PairwiseStringEvalChain,

langchain/evaluation/comparison/eval_chain.py

@@ -1,4 +1,5 @@
 """Base classes for comparing the output of two models."""
+
 from __future__ import annotations
 
 import logging

langchain/evaluation/comparison/prompt.py

@@ -4,6 +4,7 @@ This prompt is used to compare two responses and evaluate which one best follows
 and answers the question. The prompt is based on the paper from
 Zheng, et. al. https://arxiv.org/abs/2306.05685
 """
+
 # flake8: noqa
 from langchain_core.prompts.chat import ChatPromptTemplate
 

langchain/evaluation/embedding_distance/__init__.py

@@ -1,4 +1,5 @@
 """Evaluators that measure embedding distances."""
+
 from langchain.evaluation.embedding_distance.base import (
     EmbeddingDistance,
     EmbeddingDistanceEvalChain,

langchain/evaluation/embedding_distance/base.py

@@ -1,4 +1,5 @@
 """A chain for comparing the output of two models using embeddings."""
+
 from enum import Enum
 from typing import Any, Dict, List, Optional
 

langchain/evaluation/loading.py

@@ -1,4 +1,5 @@
 """Loading datasets and evaluators."""
+
 from typing import Any, Dict, List, Optional, Sequence, Type, Union
 
 from langchain_core.language_models import BaseLanguageModel

langchain/evaluation/parsing/base.py

@@ -1,4 +1,5 @@
 """Evaluators for parsing strings."""
+
 import json
 from operator import eq
 from typing import Any, Callable, Optional, Union, cast

langchain/evaluation/qa/__init__.py

@@ -1,4 +1,5 @@
 """Chains and utils related to evaluating question answering functionality."""
+
 from langchain.evaluation.qa.eval_chain import (
     ContextQAEvalChain,
     CotQAEvalChain,

langchain/evaluation/qa/eval_chain.py

@@ -1,4 +1,5 @@
 """LLM Chains for evaluating question answering."""
+
 from __future__ import annotations
 
 import re

langchain/evaluation/qa/generate_chain.py

@@ -1,4 +1,5 @@
 """LLM Chain for generating examples for question answering."""
+
 from __future__ import annotations
 
 from typing import Any

langchain/evaluation/schema.py

@@ -1,4 +1,5 @@
 """Interfaces to be implemented by general evaluators."""
+
 from __future__ import annotations
 
 import logging

langchain/evaluation/scoring/__init__.py

@@ -22,6 +22,7 @@ Example:
     #    "However, it does not provide an explanation of what the formula means."
     # }
 """
+
 from langchain.evaluation.scoring.eval_chain import (
     LabeledScoreStringEvalChain,
     ScoreStringEvalChain,

langchain/evaluation/scoring/eval_chain.py

@@ -1,4 +1,5 @@
 """Base classes for scoring the output of a model on a scale of 1-10."""
+
 from __future__ import annotations
 
 import logging

langchain/evaluation/scoring/prompt.py

@@ -4,6 +4,7 @@ This prompt is used to score the responses and evaluate how it follows the instr
 and answers the question. The prompt is based on the paper from
 Zheng, et. al. https://arxiv.org/abs/2306.05685
 """
+
 # flake8: noqa
 from langchain_core.prompts.chat import ChatPromptTemplate
 

langchain/evaluation/string_distance/__init__.py

@@ -1,4 +1,5 @@
 """String distance evaluators."""
+
 from langchain.evaluation.string_distance.base import (
     PairwiseStringDistanceEvalChain,
     StringDistance,

langchain/example_generator.py

@@ -1,4 +1,5 @@
 """Keep here for backwards compatibility."""
+
 from langchain.chains.example_generator import generate_example
 
 __all__ = ["generate_example"]

langchain/formatting.py

@@ -1,4 +1,5 @@
 """DEPRECATED: Kept for backwards compatibility."""
+
 from langchain_core.utils.formatting import StrictFormatter, formatter
 
 __all__ = ["StrictFormatter", "formatter"]

langchain/globals/__init__.py

@@ -1,4 +1,5 @@
 """Global values and configuration that apply to all of LangChain."""
+
 import warnings
 from typing import TYPE_CHECKING, Optional
 

langchain/graphs/__init__.py

@@ -1,4 +1,5 @@
 """**Graphs** provide a natural language interface to graph databases."""
+
 from typing import TYPE_CHECKING, Any
 
 from langchain._api import create_importer

langchain/indexes/__init__.py

@@ -11,6 +11,7 @@ Importantly, Index keeps on working even if the content being written is derived
 via a set of transformations from some source content (e.g., indexing children
 documents that were derived from parent documents by chunking.)
 """
+
 from typing import TYPE_CHECKING, Any
 
 from langchain_core.indexing.api import IndexingResult, aindex, index

langchain/indexes/_sql_record_manager.py

@@ -38,8 +38,7 @@ from sqlalchemy.ext.asyncio import (
     AsyncSession,
     create_async_engine,
 )
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import Query, Session, sessionmaker
+from sqlalchemy.orm import Query, Session, declarative_base, sessionmaker
 
 try:
     from sqlalchemy.ext.asyncio import async_sessionmaker

langchain/indexes/graph.py

@@ -1,4 +1,5 @@
 """**Graphs** provide a natural language interface to graph databases."""
+
 from typing import TYPE_CHECKING, Any
 
 from langchain._api import create_importer

langchain/indexes/prompts/__init__.py

@@ -1,4 +1,5 @@
 """Relevant prompts for constructing indexes."""
+
 from langchain_core._api import warn_deprecated
 
 warn_deprecated(

langchain/input.py

@@ -1,4 +1,5 @@
 """DEPRECATED: Kept for backwards compatibility."""
+
 from langchain_core.utils.input import (
     get_bolded_text,
     get_color_mapping,

langchain/llms/__init__.py

@@ -17,6 +17,7 @@ access to the large language model (**LLM**) APIs and services.
     CallbackManager, AsyncCallbackManager,
     AIMessage, BaseMessage
 """  # noqa: E501
+
 import warnings
 from typing import Any, Callable, Dict, Type
 

langchain/load/__init__.py

@@ -1,4 +1,5 @@
 """Serialization and deserialization."""
+
 from langchain_core.load.dump import dumpd, dumps
 from langchain_core.load.load import load, loads
 

langchain/memory/__init__.py

@@ -26,6 +26,7 @@
 
     AIMessage, BaseMessage, HumanMessage
 """  # noqa: E501
+
 from typing import TYPE_CHECKING, Any
 
 from langchain._api import create_importer
@@ -48,6 +49,9 @@ from langchain.memory.summary import ConversationSummaryMemory
 from langchain.memory.summary_buffer import ConversationSummaryBufferMemory
 from langchain.memory.token_buffer import ConversationTokenBufferMemory
 from langchain.memory.vectorstore import VectorStoreRetrieverMemory
+from langchain.memory.vectorstore_token_buffer_memory import (
+    ConversationVectorStoreTokenBufferMemory,  # avoid circular import
+)
 
 if TYPE_CHECKING:
     from langchain_community.chat_message_histories import (
@@ -122,6 +126,7 @@ __all__ = [
     "ConversationSummaryBufferMemory",
     "ConversationSummaryMemory",
     "ConversationTokenBufferMemory",
+    "ConversationVectorStoreTokenBufferMemory",
     "CosmosDBChatMessageHistory",
     "DynamoDBChatMessageHistory",
     "ElasticsearchChatMessageHistory",

langchain/memory/vectorstore_token_buffer_memory.py

@@ -0,0 +1,184 @@
+"""
+Class for a conversation memory buffer with older messages stored in a vectorstore .
+
+This implementats a conversation memory in which the messages are stored in a memory
+buffer up to a specified token limit. When the limit is exceeded, older messages are
+saved to a vectorstore backing database. The vectorstore can be made persistent across
+sessions.
+"""
+
+import warnings
+from datetime import datetime
+from typing import Any, Dict, List
+
+from langchain_core.messages import BaseMessage
+from langchain_core.prompts.chat import SystemMessagePromptTemplate
+from langchain_core.pydantic_v1 import Field, PrivateAttr
+from langchain_core.vectorstores import VectorStoreRetriever
+
+from langchain.memory import ConversationTokenBufferMemory, VectorStoreRetrieverMemory
+from langchain.memory.chat_memory import BaseChatMemory
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+DEFAULT_HISTORY_TEMPLATE = """
+Current date and time: {current_time}.
+
+Potentially relevant timestamped excerpts of previous conversations (you 
+do not need to use these if irrelevant):
+{previous_history}
+
+"""
+
+TIMESTAMP_FORMAT = "%Y-%m-%d %H:%M:%S %Z"
+
+
+class ConversationVectorStoreTokenBufferMemory(ConversationTokenBufferMemory):
+    """Conversation chat memory with token limit and vectordb backing.
+
+    load_memory_variables() will return a dict with the key "history".
+    It contains background information retrieved from the vector store
+    plus recent lines of the current conversation.
+
+    To help the LLM understand the part of the conversation stored in the
+    vectorstore, each interaction is timestamped and the current date and
+    time is also provided in the history. A side effect of this is that the
+    LLM will have access to the current date and time.
+
+    Initialization arguments:
+
+    This class accepts all the initialization arguments of
+    ConversationTokenBufferMemory, such as `llm`. In addition, it
+    accepts the following additional arguments
+
+        retriever: (required) A VectorStoreRetriever object to use
+                   as the vector backing store
+
+        split_chunk_size: (optional, 1000) Token chunk split size
+                          for long messages generated by the AI
+
+        previous_history_template: (optional) Template used to format
+                                   the contents of the prompt history
+
+
+    Example using ChromaDB:
+
+    .. code-block:: python
+
+        from langchain.memory.token_buffer_vectorstore_memory import (
+                ConversationVectorStoreTokenBufferMemory
+        )
+        from langchain_community.vectorstores import Chroma
+        from langchain_community.embeddings import HuggingFaceInstructEmbeddings
+        from langchain_openai import OpenAI
+
+        embedder = HuggingFaceInstructEmbeddings(
+                        query_instruction="Represent the query for retrieval: "
+        )
+        chroma = Chroma(collection_name="demo",
+                        embedding_function=embedder,
+                        collection_metadata={"hnsw:space": "cosine"},
+                        )
+
+        retriever = chroma.as_retriever(
+                search_type="similarity_score_threshold",
+                search_kwargs={
+                    'k': 5,
+                    'score_threshold': 0.75,
+                },
+        )
+
+        conversation_memory = ConversationVectorStoreTokenBufferMemory(
+                return_messages=True,
+                llm=OpenAI(),
+                retriever=retriever,
+                max_token_limit = 1000,
+        )
+
+        conversation_memory.save_context({"Human": "Hi there"},
+                                          {"AI": "Nice to meet you!"}
+        )
+        conversation_memory.save_context({"Human": "Nice day isn't it?"},
+                                          {"AI": "I love Wednesdays."}
+        )
+        conversation_memory.load_memory_variables({"input": "What time is it?"})
+
+    """
+
+    retriever: VectorStoreRetriever = Field(exclude=True)
+    memory_key: str = "history"
+    previous_history_template: str = DEFAULT_HISTORY_TEMPLATE
+    split_chunk_size: int = 1000
+
+    _memory_retriever: VectorStoreRetrieverMemory = PrivateAttr(default=None)
+    _timestamps: List[datetime] = PrivateAttr(default_factory=list)
+
+    @property
+    def memory_retriever(self) -> VectorStoreRetrieverMemory:
+        """Return a memory retriever from the passed retriever object."""
+        if self._memory_retriever is not None:
+            return self._memory_retriever
+        self._memory_retriever = VectorStoreRetrieverMemory(retriever=self.retriever)
+        return self._memory_retriever
+
+    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        """Return history and memory buffer."""
+        try:
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                memory_variables = self.memory_retriever.load_memory_variables(inputs)
+            previous_history = memory_variables[self.memory_retriever.memory_key]
+        except AssertionError:  # happens when db is empty
+            previous_history = ""
+        current_history = super().load_memory_variables(inputs)
+        template = SystemMessagePromptTemplate.from_template(
+            self.previous_history_template
+        )
+        messages = [
+            template.format(
+                previous_history=previous_history,
+                current_time=datetime.now().astimezone().strftime(TIMESTAMP_FORMAT),
+            )
+        ]
+        messages.extend(current_history[self.memory_key])
+        return {self.memory_key: messages}
+
+    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
+        """Save context from this conversation to buffer. Pruned."""
+        BaseChatMemory.save_context(self, inputs, outputs)
+        self._timestamps.append(datetime.now().astimezone())
+        # Prune buffer if it exceeds max token limit
+        buffer = self.chat_memory.messages
+        curr_buffer_length = self.llm.get_num_tokens_from_messages(buffer)
+        if curr_buffer_length > self.max_token_limit:
+            while curr_buffer_length > self.max_token_limit:
+                self._pop_and_store_interaction(buffer)
+                curr_buffer_length = self.llm.get_num_tokens_from_messages(buffer)
+
+    def save_remainder(self) -> None:
+        """
+        Save the remainder of the conversation buffer to the vector store.
+
+        This is useful if you have made the vectorstore persistent, in which
+        case this can be called before the end of the session to store the
+        remainder of the conversation.
+        """
+        buffer = self.chat_memory.messages
+        while len(buffer) > 0:
+            self._pop_and_store_interaction(buffer)
+
+    def _pop_and_store_interaction(self, buffer: List[BaseMessage]) -> None:
+        input = buffer.pop(0)
+        output = buffer.pop(0)
+        timestamp = self._timestamps.pop(0).strftime(TIMESTAMP_FORMAT)
+        # Split AI output into smaller chunks to avoid creating documents
+        # that will overflow the context window
+        ai_chunks = self._split_long_ai_text(str(output.content))
+        for index, chunk in enumerate(ai_chunks):
+            self.memory_retriever.save_context(
+                {"Human": f"<{timestamp}/00> {str(input.content)}"},
+                {"AI": f"<{timestamp}/{index:02}> {chunk}"},
+            )
+
+    def _split_long_ai_text(self, text: str) -> List[str]:
+        splitter = RecursiveCharacterTextSplitter(chunk_size=self.split_chunk_size)
+        return [chunk.page_content for chunk in splitter.create_documents([text])]

langchain/output_parsers/__init__.py

@@ -12,6 +12,7 @@
 
     Serializable, Generation, PromptValue
 """  # noqa: E501
+
 from typing import TYPE_CHECKING, Any
 
 from langchain_core.output_parsers import (

langchain/prompts/__init__.py

@@ -27,6 +27,7 @@ from multiple components. Prompt classes and functions make constructing
                     ChatPromptValue
 
 """  # noqa: E501
+
 from typing import TYPE_CHECKING, Any
 
 from langchain_core.example_selectors import (

langchain/prompts/example_selector/__init__.py

@@ -1,4 +1,5 @@
 """Logic for selecting examples to include in prompts."""
+
 from typing import TYPE_CHECKING, Any
 
 from langchain_core.example_selectors.length_based import (

langchain/python.py

@@ -1,4 +1,5 @@
 """For backwards compatibility."""
+
 from typing import Any
 
 from langchain._api import create_importer

langchain/requests.py

@@ -1,4 +1,5 @@
 """DEPRECATED: Kept for backwards compatibility."""
+
 from typing import TYPE_CHECKING, Any
 
 from langchain._api import create_importer

langchain/retrievers/__init__.py

@@ -17,6 +17,7 @@ the backbone of a retriever, but there are other types of retrievers as well.
     Document, Serializable, Callbacks,
     CallbackManagerForRetrieverRun, AsyncCallbackManagerForRetrieverRun
 """
+
 from typing import TYPE_CHECKING, Any
 
 from langchain._api.module_import import create_importer

langchain/retrievers/document_compressors/chain_extract.py

@@ -1,4 +1,5 @@
 """DocumentFilter that uses an LLM chain to extract the relevant parts of documents."""
+
 from __future__ import annotations
 
 import asyncio

langchain/retrievers/document_compressors/chain_filter.py

@@ -1,4 +1,5 @@
 """Filter that uses an LLM to drop documents that aren't relevant to the query."""
+
 from typing import Any, Callable, Dict, Optional, Sequence
 
 from langchain_core.callbacks.manager import Callbacks

langchain/retrievers/ensemble.py

@@ -2,6 +2,7 @@
 Ensemble retriever that ensemble the results of
 multiple retrievers by using weighted  Reciprocal Rank Fusion
 """
+
 import asyncio
 from collections import defaultdict
 from collections.abc import Hashable

langchain/retrievers/self_query/base.py

@@ -169,7 +169,7 @@ def _get_builtin_translator(vectorstore: VectorStore) -> Visitor:
                 return ChromaTranslator()
 
         try:
-            from langchain_postgres import PGVector
+            from langchain_postgres import PGVector  # type: ignore[no-redef]
             from langchain_postgres import PGVectorTranslator as NewPGVectorTranslator
         except ImportError:
             pass
@@ -310,16 +310,16 @@ class SelfQueryRetriever(BaseRetriever):
             "allowed_comparators" not in chain_kwargs
             and structured_query_translator.allowed_comparators is not None
         ):
-            chain_kwargs[
-                "allowed_comparators"
-            ] = structured_query_translator.allowed_comparators
+            chain_kwargs["allowed_comparators"] = (
+                structured_query_translator.allowed_comparators
+            )
         if (
             "allowed_operators" not in chain_kwargs
             and structured_query_translator.allowed_operators is not None
         ):
-            chain_kwargs[
-                "allowed_operators"
-            ] = structured_query_translator.allowed_operators
+            chain_kwargs["allowed_operators"] = (
+                structured_query_translator.allowed_operators
+            )
         query_constructor = load_query_constructor_runnable(
             llm,
             document_contents,

langchain/schema/__init__.py

@@ -1,4 +1,5 @@
 """**Schemas** are the LangChain Base Classes and Interfaces."""
+
 from langchain_core.agents import AgentAction, AgentFinish
 from langchain_core.caches import BaseCache
 from langchain_core.chat_history import BaseChatMessageHistory

langchain/schema/runnable/__init__.py

@@ -14,6 +14,7 @@ creating more responsive UX.
 
 This module contains schema and implementation of LangChain Runnables primitives.
 """
+
 from langchain_core.runnables.base import (
     Runnable,
     RunnableBinding,

langchain/serpapi.py

@@ -1,4 +1,5 @@
 """For backwards compatibility."""
+
 from typing import TYPE_CHECKING, Any
 
 from langchain._api import create_importer

langchain/smith/__init__.py

@@ -54,19 +54,19 @@ or LangSmith's `RunEvaluator` classes.
     from langchain.evaluation import StringEvaluator
 
     class MyStringEvaluator(StringEvaluator):
-        
+
         @property
         def requires_input(self) -> bool:
             return False
-        
+
         @property
         def requires_reference(self) -> bool:
             return True
-        
+
         @property
         def evaluation_name(self) -> str:
             return "exact_match"
-        
+
         def _evaluate_strings(self, prediction, reference=None, input=None, **kwargs) -> dict:
             return {"score": prediction == reference}
 
@@ -80,7 +80,7 @@ or LangSmith's `RunEvaluator` classes.
         "<my_dataset_name>",
         construct_chain,
         evaluation=evaluation_config,
-    )    
+    )
 
 **Primary Functions**
 
@@ -88,6 +88,7 @@ or LangSmith's `RunEvaluator` classes.
 - :func:`run_on_dataset <langchain.smith.evaluation.runner_utils.run_on_dataset>`: Function to evaluate a chain, agent, or other LangChain component over a dataset.
 - :class:`RunEvalConfig <langchain.smith.evaluation.config.RunEvalConfig>`: Class representing the configuration for running evaluation. You can select evaluators by :class:`EvaluatorType <langchain.evaluation.schema.EvaluatorType>` or config, or you can pass in `custom_evaluators`
 """  # noqa: E501
+
 from langchain.smith.evaluation import (
     RunEvalConfig,
     arun_on_dataset,

langchain/smith/evaluation/__init__.py

@@ -51,7 +51,6 @@ For more information on the LangSmith API, see the `LangSmith API documentation
 
 """  # noqa: E501
 
-
 from langchain.smith.evaluation.config import RunEvalConfig
 from langchain.smith.evaluation.runner_utils import (
     InputFormatError,

langchain/smith/evaluation/string_run_evaluator.py

@@ -1,4 +1,5 @@
 """Run evaluator wrapper for string evaluators."""
+
 from __future__ import annotations
 
 from abc import abstractmethod