langchain 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

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/output_parsers/combining.py

@@ -6,7 +6,7 @@ from langchain_core.output_parsers import BaseOutputParser
 from langchain_core.pydantic_v1 import root_validator
 
 
-class CombiningOutputParser(BaseOutputParser):
+class CombiningOutputParser(BaseOutputParser[Dict[str, Any]]):
     """Combine multiple output parsers into one."""
 
     parsers: List[BaseOutputParser]

langchain/output_parsers/enum.py

@@ -1,12 +1,12 @@
 from enum import Enum
-from typing import Any, Dict, List, Type
+from typing import Dict, List, Type
 
 from langchain_core.exceptions import OutputParserException
 from langchain_core.output_parsers import BaseOutputParser
 from langchain_core.pydantic_v1 import root_validator
 
 
-class EnumOutputParser(BaseOutputParser):
+class EnumOutputParser(BaseOutputParser[Enum]):
     """Parse an output that is one of a set of values."""
 
     enum: Type[Enum]
@@ -23,7 +23,7 @@ class EnumOutputParser(BaseOutputParser):
     def _valid_values(self) -> List[str]:
         return [e.value for e in self.enum]
 
-    def parse(self, response: str) -> Any:
+    def parse(self, response: str) -> Enum:
         try:
             return self.enum(response.strip())
         except ValueError:
@@ -34,3 +34,7 @@ class EnumOutputParser(BaseOutputParser):
 
     def get_format_instructions(self) -> str:
         return f"Select one of the following options: {', '.join(self._valid_values)}"
+
+    @property
+    def OutputType(self) -> Type[Enum]:
+        return self.enum

langchain/output_parsers/fix.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
-from typing import Any, TypeVar
+from typing import Any, TypeVar, Union
 
 from langchain_core.exceptions import OutputParserException
 from langchain_core.language_models import BaseLanguageModel
 from langchain_core.output_parsers import BaseOutputParser
 from langchain_core.prompts import BasePromptTemplate
+from langchain_core.runnables import RunnableSerializable
 
 from langchain.output_parsers.prompts import NAIVE_FIX_PROMPT
 
@@ -22,10 +23,12 @@ class OutputFixingParser(BaseOutputParser[T]):
     parser: BaseOutputParser[T]
     """The parser to use to parse the output."""
     # Should be an LLMChain but we want to avoid top-level imports from langchain.chains
-    retry_chain: Any
-    """The LLMChain to use to retry the completion."""
+    retry_chain: Union[RunnableSerializable, Any]
+    """The RunnableSerializable to use to retry the completion (Legacy: LLMChain)."""
     max_retries: int = 1
     """The maximum number of times to retry the parse."""
+    legacy: bool = True
+    """Whether to use the run or arun method of the retry_chain."""
 
     @classmethod
     def from_llm(
@@ -46,9 +49,7 @@ class OutputFixingParser(BaseOutputParser[T]):
         Returns:
             OutputFixingParser
         """
-        from langchain.chains.llm import LLMChain
-
-        chain = LLMChain(llm=llm, prompt=prompt)
+        chain = prompt | llm
         return cls(parser=parser, retry_chain=chain, max_retries=max_retries)
 
     def parse(self, completion: str) -> T:
@@ -62,11 +63,29 @@ class OutputFixingParser(BaseOutputParser[T]):
                     raise e
                 else:
                     retries += 1
-                    completion = self.retry_chain.run(
-                        instructions=self.parser.get_format_instructions(),
-                        completion=completion,
-                        error=repr(e),
-                    )
+                    if self.legacy and hasattr(self.retry_chain, "run"):
+                        completion = self.retry_chain.run(
+                            instructions=self.parser.get_format_instructions(),
+                            completion=completion,
+                            error=repr(e),
+                        )
+                    else:
+                        try:
+                            completion = self.retry_chain.invoke(
+                                dict(
+                                    instructions=self.parser.get_format_instructions(),  # noqa: E501
+                                    input=completion,
+                                    error=repr(e),
+                                )
+                            )
+                        except (NotImplementedError, AttributeError):
+                            # Case: self.parser does not have get_format_instructions  # noqa: E501
+                            completion = self.retry_chain.invoke(
+                                dict(
+                                    input=completion,
+                                    error=repr(e),
+                                )
+                            )
 
         raise OutputParserException("Failed to parse")
 
@@ -81,11 +100,29 @@ class OutputFixingParser(BaseOutputParser[T]):
                     raise e
                 else:
                     retries += 1
-                    completion = await self.retry_chain.arun(
-                        instructions=self.parser.get_format_instructions(),
-                        completion=completion,
-                        error=repr(e),
-                    )
+                    if self.legacy and hasattr(self.retry_chain, "arun"):
+                        completion = await self.retry_chain.arun(
+                            instructions=self.parser.get_format_instructions(),  # noqa: E501
+                            completion=completion,
+                            error=repr(e),
+                        )
+                    else:
+                        try:
+                            completion = await self.retry_chain.ainvoke(
+                                dict(
+                                    instructions=self.parser.get_format_instructions(),  # noqa: E501
+                                    input=completion,
+                                    error=repr(e),
+                                )
+                            )
+                        except (NotImplementedError, AttributeError):
+                            # Case: self.parser does not have get_format_instructions  # noqa: E501
+                            completion = await self.retry_chain.ainvoke(
+                                dict(
+                                    input=completion,
+                                    error=repr(e),
+                                )
+                            )
 
         raise OutputParserException("Failed to parse")
 
@@ -95,3 +132,7 @@ class OutputFixingParser(BaseOutputParser[T]):
     @property
     def _type(self) -> str:
         return "output_fixing"
+
+    @property
+    def OutputType(self) -> type[T]:
+        return self.parser.OutputType

langchain/output_parsers/pandas_dataframe.py

@@ -10,7 +10,7 @@ from langchain.output_parsers.format_instructions import (
 )
 
 
-class PandasDataFrameOutputParser(BaseOutputParser):
+class PandasDataFrameOutputParser(BaseOutputParser[Dict[str, Any]]):
     """Parse an output using Pandas DataFrame format."""
 
     """The Pandas DataFrame to parse."""

langchain/output_parsers/regex.py

@@ -6,7 +6,7 @@ from typing import Dict, List, Optional
 from langchain_core.output_parsers import BaseOutputParser
 
 
-class RegexParser(BaseOutputParser):
+class RegexParser(BaseOutputParser[Dict[str, str]]):
     """Parse the output of an LLM call using a regex."""
 
     @classmethod

langchain/output_parsers/regex_dict.py

@@ -6,7 +6,7 @@ from typing import Dict, Optional
 from langchain_core.output_parsers import BaseOutputParser
 
 
-class RegexDictParser(BaseOutputParser):
+class RegexDictParser(BaseOutputParser[Dict[str, str]]):
     """Parse the output of an LLM call into a Dictionary using a regex."""
 
     regex_pattern: str = r"{}:\s?([^.'\n']*)\.?"  # : :meta private:

langchain/output_parsers/retry.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
-from typing import Any, TypeVar
+from typing import Any, TypeVar, Union
 
 from langchain_core.exceptions import OutputParserException
 from langchain_core.language_models import BaseLanguageModel
 from langchain_core.output_parsers import BaseOutputParser
 from langchain_core.prompt_values import PromptValue
 from langchain_core.prompts import BasePromptTemplate, PromptTemplate
+from langchain_core.runnables import RunnableSerializable
 
 NAIVE_COMPLETION_RETRY = """Prompt:
 {prompt}
@@ -43,10 +44,12 @@ class RetryOutputParser(BaseOutputParser[T]):
     parser: BaseOutputParser[T]
     """The parser to use to parse the output."""
     # Should be an LLMChain but we want to avoid top-level imports from langchain.chains
-    retry_chain: Any
-    """The LLMChain to use to retry the completion."""
+    retry_chain: Union[RunnableSerializable, Any]
+    """The RunnableSerializable to use to retry the completion (Legacy: LLMChain)."""
     max_retries: int = 1
     """The maximum number of times to retry the parse."""
+    legacy: bool = True
+    """Whether to use the run or arun method of the retry_chain."""
 
     @classmethod
     def from_llm(
@@ -67,9 +70,7 @@ class RetryOutputParser(BaseOutputParser[T]):
         Returns:
             RetryOutputParser
         """
-        from langchain.chains.llm import LLMChain
-
-        chain = LLMChain(llm=llm, prompt=prompt)
+        chain = prompt | llm
         return cls(parser=parser, retry_chain=chain, max_retries=max_retries)
 
     def parse_with_prompt(self, completion: str, prompt_value: PromptValue) -> T:
@@ -92,9 +93,19 @@ class RetryOutputParser(BaseOutputParser[T]):
                     raise e
                 else:
                     retries += 1
-                    completion = self.retry_chain.run(
-                        prompt=prompt_value.to_string(), completion=completion
-                    )
+                    if self.legacy and hasattr(self.retry_chain, "run"):
+                        completion = self.retry_chain.run(
+                            prompt=prompt_value.to_string(),
+                            completion=completion,
+                            error=repr(e),
+                        )
+                    else:
+                        completion = self.retry_chain.invoke(
+                            dict(
+                                prompt=prompt_value.to_string(),
+                                input=completion,
+                            )
+                        )
 
         raise OutputParserException("Failed to parse")
 
@@ -118,9 +129,19 @@ class RetryOutputParser(BaseOutputParser[T]):
                     raise e
                 else:
                     retries += 1
-                    completion = await self.retry_chain.arun(
-                        prompt=prompt_value.to_string(), completion=completion
-                    )
+                    if self.legacy and hasattr(self.retry_chain, "arun"):
+                        completion = await self.retry_chain.arun(
+                            prompt=prompt_value.to_string(),
+                            completion=completion,
+                            error=repr(e),
+                        )
+                    else:
+                        completion = await self.retry_chain.ainvoke(
+                            dict(
+                                prompt=prompt_value.to_string(),
+                                input=completion,
+                            )
+                        )
 
         raise OutputParserException("Failed to parse")
 
@@ -136,6 +157,10 @@ class RetryOutputParser(BaseOutputParser[T]):
     def _type(self) -> str:
         return "retry"
 
+    @property
+    def OutputType(self) -> type[T]:
+        return self.parser.OutputType
+
 
 class RetryWithErrorOutputParser(BaseOutputParser[T]):
     """Wrap a parser and try to fix parsing errors.
@@ -149,11 +174,13 @@ class RetryWithErrorOutputParser(BaseOutputParser[T]):
 
     parser: BaseOutputParser[T]
     """The parser to use to parse the output."""
-    # Should be an LLMChain but we want to avoid top-level imports from langchain.chains
-    retry_chain: Any
-    """The LLMChain to use to retry the completion."""
+    # Should be an LLMChain but we want to avoid top-level imports from langchain.chains  # noqa: E501
+    retry_chain: Union[RunnableSerializable, Any]
+    """The RunnableSerializable to use to retry the completion (Legacy: LLMChain)."""
     max_retries: int = 1
     """The maximum number of times to retry the parse."""
+    legacy: bool = True
+    """Whether to use the run or arun method of the retry_chain."""
 
     @classmethod
     def from_llm(
@@ -174,12 +201,10 @@ class RetryWithErrorOutputParser(BaseOutputParser[T]):
         Returns:
             A RetryWithErrorOutputParser.
         """
-        from langchain.chains.llm import LLMChain
-
-        chain = LLMChain(llm=llm, prompt=prompt)
+        chain = prompt | llm
         return cls(parser=parser, retry_chain=chain, max_retries=max_retries)
 
-    def parse_with_prompt(self, completion: str, prompt_value: PromptValue) -> T:
+    def parse_with_prompt(self, completion: str, prompt_value: PromptValue) -> T:  # noqa: E501
         retries = 0
 
         while retries <= self.max_retries:
@@ -190,11 +215,20 @@ class RetryWithErrorOutputParser(BaseOutputParser[T]):
                     raise e
                 else:
                     retries += 1
-                    completion = self.retry_chain.run(
-                        prompt=prompt_value.to_string(),
-                        completion=completion,
-                        error=repr(e),
-                    )
+                    if self.legacy and hasattr(self.retry_chain, "run"):
+                        completion = self.retry_chain.run(
+                            prompt=prompt_value.to_string(),
+                            completion=completion,
+                            error=repr(e),
+                        )
+                    else:
+                        completion = self.retry_chain.invoke(
+                            dict(
+                                input=completion,
+                                prompt=prompt_value.to_string(),
+                                error=repr(e),
+                            )
+                        )
 
         raise OutputParserException("Failed to parse")
 
@@ -209,11 +243,20 @@ class RetryWithErrorOutputParser(BaseOutputParser[T]):
                     raise e
                 else:
                     retries += 1
-                    completion = await self.retry_chain.arun(
-                        prompt=prompt_value.to_string(),
-                        completion=completion,
-                        error=repr(e),
-                    )
+                    if self.legacy and hasattr(self.retry_chain, "arun"):
+                        completion = await self.retry_chain.arun(
+                            prompt=prompt_value.to_string(),
+                            completion=completion,
+                            error=repr(e),
+                        )
+                    else:
+                        completion = await self.retry_chain.ainvoke(
+                            dict(
+                                prompt=prompt_value.to_string(),
+                                input=completion,
+                                error=repr(e),
+                            )
+                        )
 
         raise OutputParserException("Failed to parse")
 
@@ -228,3 +271,7 @@ class RetryWithErrorOutputParser(BaseOutputParser[T]):
     @property
     def _type(self) -> str:
         return "retry_with_error"
+
+    @property
+    def OutputType(self) -> type[T]:
+        return self.parser.OutputType

langchain/output_parsers/structured.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, List
+from typing import Any, Dict, List
 
 from langchain_core.output_parsers import BaseOutputParser
 from langchain_core.output_parsers.json import parse_and_check_json_markdown
@@ -31,7 +31,7 @@ def _get_sub_string(schema: ResponseSchema) -> str:
     )
 
 
-class StructuredOutputParser(BaseOutputParser):
+class StructuredOutputParser(BaseOutputParser[Dict[str, Any]]):
     """Parse the output of an LLM call to a structured output."""
 
     response_schemas: List[ResponseSchema]
@@ -92,7 +92,7 @@ class StructuredOutputParser(BaseOutputParser):
         else:
             return STRUCTURED_FORMAT_INSTRUCTIONS.format(format=schema_str)
 
-    def parse(self, text: str) -> Any:
+    def parse(self, text: str) -> Dict[str, Any]:
         expected_keys = [rs.name for rs in self.response_schemas]
         return parse_and_check_json_markdown(text, expected_keys)
 

langchain/output_parsers/yaml.py

@@ -60,3 +60,7 @@ class YamlOutputParser(BaseOutputParser[T]):
     @property
     def _type(self) -> str:
         return "yaml"
+
+    @property
+    def OutputType(self) -> Type[T]:
+        return self.pydantic_object

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