langchain 0.4.0.dev0__py3-none-any.whl → 1.0.0a2__py3-none-any.whl

langchain/memory/kg.py

@@ -1,23 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.memory.kg import ConversationKGMemory
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {"ConversationKGMemory": "langchain_community.memory.kg"}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "ConversationKGMemory",
-]

langchain/memory/motorhead_memory.py

@@ -1,23 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.memory.motorhead_memory import MotorheadMemory
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {"MotorheadMemory": "langchain_community.memory.motorhead_memory"}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "MotorheadMemory",
-]

langchain/memory/prompt.py

@@ -1,164 +0,0 @@
-from langchain_core.prompts.prompt import PromptTemplate
-
-_DEFAULT_ENTITY_MEMORY_CONVERSATION_TEMPLATE = """You are an assistant to a human, powered by a large language model trained by OpenAI.
-
-You are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.
-
-You are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics.
-
-Overall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist.
-
-Context:
-{entities}
-
-Current conversation:
-{history}
-Last line:
-Human: {input}
-You:"""  # noqa: E501
-
-ENTITY_MEMORY_CONVERSATION_TEMPLATE = PromptTemplate(
-    input_variables=["entities", "history", "input"],
-    template=_DEFAULT_ENTITY_MEMORY_CONVERSATION_TEMPLATE,
-)
-
-_DEFAULT_SUMMARIZER_TEMPLATE = """Progressively summarize the lines of conversation provided, adding onto the previous summary returning a new summary.
-
-EXAMPLE
-Current summary:
-The human asks what the AI thinks of artificial intelligence. The AI thinks artificial intelligence is a force for good.
-
-New lines of conversation:
-Human: Why do you think artificial intelligence is a force for good?
-AI: Because artificial intelligence will help humans reach their full potential.
-
-New summary:
-The human asks what the AI thinks of artificial intelligence. The AI thinks artificial intelligence is a force for good because it will help humans reach their full potential.
-END OF EXAMPLE
-
-Current summary:
-{summary}
-
-New lines of conversation:
-{new_lines}
-
-New summary:"""  # noqa: E501
-SUMMARY_PROMPT = PromptTemplate(
-    input_variables=["summary", "new_lines"], template=_DEFAULT_SUMMARIZER_TEMPLATE
-)
-
-_DEFAULT_ENTITY_EXTRACTION_TEMPLATE = """You are an AI assistant reading the transcript of a conversation between an AI and a human. Extract all of the proper nouns from the last line of conversation. As a guideline, a proper noun is generally capitalized. You should definitely extract all names and places.
-
-The conversation history is provided just in case of a coreference (e.g. "What do you know about him" where "him" is defined in a previous line) -- ignore items mentioned there that are not in the last line.
-
-Return the output as a single comma-separated list, or NONE if there is nothing of note to return (e.g. the user is just issuing a greeting or having a simple conversation).
-
-EXAMPLE
-Conversation history:
-Person #1: how's it going today?
-AI: "It's going great! How about you?"
-Person #1: good! busy working on Langchain. lots to do.
-AI: "That sounds like a lot of work! What kind of things are you doing to make Langchain better?"
-Last line:
-Person #1: i'm trying to improve Langchain's interfaces, the UX, its integrations with various products the user might want ... a lot of stuff.
-Output: Langchain
-END OF EXAMPLE
-
-EXAMPLE
-Conversation history:
-Person #1: how's it going today?
-AI: "It's going great! How about you?"
-Person #1: good! busy working on Langchain. lots to do.
-AI: "That sounds like a lot of work! What kind of things are you doing to make Langchain better?"
-Last line:
-Person #1: i'm trying to improve Langchain's interfaces, the UX, its integrations with various products the user might want ... a lot of stuff. I'm working with Person #2.
-Output: Langchain, Person #2
-END OF EXAMPLE
-
-Conversation history (for reference only):
-{history}
-Last line of conversation (for extraction):
-Human: {input}
-
-Output:"""  # noqa: E501
-ENTITY_EXTRACTION_PROMPT = PromptTemplate(
-    input_variables=["history", "input"], template=_DEFAULT_ENTITY_EXTRACTION_TEMPLATE
-)
-
-_DEFAULT_ENTITY_SUMMARIZATION_TEMPLATE = """You are an AI assistant helping a human keep track of facts about relevant people, places, and concepts in their life. Update the summary of the provided entity in the "Entity" section based on the last line of your conversation with the human. If you are writing the summary for the first time, return a single sentence.
-The update should only include facts that are relayed in the last line of conversation about the provided entity, and should only contain facts about the provided entity.
-
-If there is no new information about the provided entity or the information is not worth noting (not an important or relevant fact to remember long-term), return the existing summary unchanged.
-
-Full conversation history (for context):
-{history}
-
-Entity to summarize:
-{entity}
-
-Existing summary of {entity}:
-{summary}
-
-Last line of conversation:
-Human: {input}
-Updated summary:"""  # noqa: E501
-
-ENTITY_SUMMARIZATION_PROMPT = PromptTemplate(
-    input_variables=["entity", "summary", "history", "input"],
-    template=_DEFAULT_ENTITY_SUMMARIZATION_TEMPLATE,
-)
-
-
-KG_TRIPLE_DELIMITER = "<|>"
-_DEFAULT_KNOWLEDGE_TRIPLE_EXTRACTION_TEMPLATE = (
-    "You are a networked intelligence helping a human track knowledge triples"
-    " about all relevant people, things, concepts, etc. and integrating"
-    " them with your knowledge stored within your weights"
-    " as well as that stored in a knowledge graph."
-    " Extract all of the knowledge triples from the last line of conversation."
-    " A knowledge triple is a clause that contains a subject, a predicate,"
-    " and an object. The subject is the entity being described,"
-    " the predicate is the property of the subject that is being"
-    " described, and the object is the value of the property.\n\n"
-    "EXAMPLE\n"
-    "Conversation history:\n"
-    "Person #1: Did you hear aliens landed in Area 51?\n"
-    "AI: No, I didn't hear that. What do you know about Area 51?\n"
-    "Person #1: It's a secret military base in Nevada.\n"
-    "AI: What do you know about Nevada?\n"
-    "Last line of conversation:\n"
-    "Person #1: It's a state in the US. It's also the number 1 producer of gold in the US.\n\n"  # noqa: E501
-    f"Output: (Nevada, is a, state){KG_TRIPLE_DELIMITER}(Nevada, is in, US)"
-    f"{KG_TRIPLE_DELIMITER}(Nevada, is the number 1 producer of, gold)\n"
-    "END OF EXAMPLE\n\n"
-    "EXAMPLE\n"
-    "Conversation history:\n"
-    "Person #1: Hello.\n"
-    "AI: Hi! How are you?\n"
-    "Person #1: I'm good. How are you?\n"
-    "AI: I'm good too.\n"
-    "Last line of conversation:\n"
-    "Person #1: I'm going to the store.\n\n"
-    "Output: NONE\n"
-    "END OF EXAMPLE\n\n"
-    "EXAMPLE\n"
-    "Conversation history:\n"
-    "Person #1: What do you know about Descartes?\n"
-    "AI: Descartes was a French philosopher, mathematician, and scientist who lived in the 17th century.\n"  # noqa: E501
-    "Person #1: The Descartes I'm referring to is a standup comedian and interior designer from Montreal.\n"  # noqa: E501
-    "AI: Oh yes, He is a comedian and an interior designer. He has been in the industry for 30 years. His favorite food is baked bean pie.\n"  # noqa: E501
-    "Last line of conversation:\n"
-    "Person #1: Oh huh. I know Descartes likes to drive antique scooters and play the mandolin.\n"  # noqa: E501
-    f"Output: (Descartes, likes to drive, antique scooters){KG_TRIPLE_DELIMITER}(Descartes, plays, mandolin)\n"  # noqa: E501
-    "END OF EXAMPLE\n\n"
-    "Conversation history (for reference only):\n"
-    "{history}"
-    "\nLast line of conversation (for extraction):\n"
-    "Human: {input}\n\n"
-    "Output:"
-)
-
-KNOWLEDGE_TRIPLE_EXTRACTION_PROMPT = PromptTemplate(
-    input_variables=["history", "input"],
-    template=_DEFAULT_KNOWLEDGE_TRIPLE_EXTRACTION_TEMPLATE,
-)

langchain/memory/readonly.py

@@ -1,24 +0,0 @@
-from typing import Any
-
-from langchain_core.memory import BaseMemory
-
-
-class ReadOnlySharedMemory(BaseMemory):
-    """Memory wrapper that is read-only and cannot be changed."""
-
-    memory: BaseMemory
-
-    @property
-    def memory_variables(self) -> list[str]:
-        """Return memory variables."""
-        return self.memory.memory_variables
-
-    def load_memory_variables(self, inputs: dict[str, Any]) -> dict[str, str]:
-        """Load memory variables from memory."""
-        return self.memory.load_memory_variables(inputs)
-
-    def save_context(self, inputs: dict[str, Any], outputs: dict[str, str]) -> None:
-        """Nothing should be saved or changed"""
-
-    def clear(self) -> None:
-        """Nothing to clear, got a memory like a vault."""

langchain/memory/simple.py

@@ -1,27 +0,0 @@
-from typing import Any
-
-from langchain_core.memory import BaseMemory
-from typing_extensions import override
-
-
-class SimpleMemory(BaseMemory):
-    """Simple memory for storing context or other information that shouldn't
-    ever change between prompts.
-    """
-
-    memories: dict[str, Any] = {}
-
-    @property
-    @override
-    def memory_variables(self) -> list[str]:
-        return list(self.memories.keys())
-
-    @override
-    def load_memory_variables(self, inputs: dict[str, Any]) -> dict[str, str]:
-        return self.memories
-
-    def save_context(self, inputs: dict[str, Any], outputs: dict[str, str]) -> None:
-        """Nothing should be saved or changed, my memory is set in stone."""
-
-    def clear(self) -> None:
-        """Nothing to clear, got a memory like a vault."""

langchain/memory/summary.py

@@ -1,170 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from langchain_core._api import deprecated
-from langchain_core.chat_history import BaseChatMessageHistory
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.messages import BaseMessage, SystemMessage, get_buffer_string
-from langchain_core.prompts import BasePromptTemplate
-from langchain_core.utils import pre_init
-from pydantic import BaseModel
-from typing_extensions import override
-
-from langchain.chains.llm import LLMChain
-from langchain.memory.chat_memory import BaseChatMemory
-from langchain.memory.prompt import SUMMARY_PROMPT
-
-
-@deprecated(
-    since="0.2.12",
-    removal="1.0",
-    message=(
-        "Refer here for how to incorporate summaries of conversation history: "
-        "https://langchain-ai.github.io/langgraph/how-tos/memory/add-summary-conversation-history/"
-    ),
-)
-class SummarizerMixin(BaseModel):
-    """Mixin for summarizer."""
-
-    human_prefix: str = "Human"
-    ai_prefix: str = "AI"
-    llm: BaseLanguageModel
-    prompt: BasePromptTemplate = SUMMARY_PROMPT
-    summary_message_cls: type[BaseMessage] = SystemMessage
-
-    def predict_new_summary(
-        self,
-        messages: list[BaseMessage],
-        existing_summary: str,
-    ) -> str:
-        """Predict a new summary based on the messages and existing summary.
-
-        Args:
-            messages: List of messages to summarize.
-            existing_summary: Existing summary to build upon.
-
-        Returns:
-            A new summary string.
-        """
-        new_lines = get_buffer_string(
-            messages,
-            human_prefix=self.human_prefix,
-            ai_prefix=self.ai_prefix,
-        )
-
-        chain = LLMChain(llm=self.llm, prompt=self.prompt)
-        return chain.predict(summary=existing_summary, new_lines=new_lines)
-
-    async def apredict_new_summary(
-        self,
-        messages: list[BaseMessage],
-        existing_summary: str,
-    ) -> str:
-        """Predict a new summary based on the messages and existing summary.
-
-        Args:
-            messages: List of messages to summarize.
-            existing_summary: Existing summary to build upon.
-
-        Returns:
-            A new summary string.
-        """
-        new_lines = get_buffer_string(
-            messages,
-            human_prefix=self.human_prefix,
-            ai_prefix=self.ai_prefix,
-        )
-
-        chain = LLMChain(llm=self.llm, prompt=self.prompt)
-        return await chain.apredict(summary=existing_summary, new_lines=new_lines)
-
-
-@deprecated(
-    since="0.3.1",
-    removal="1.0.0",
-    message=(
-        "Please see the migration guide at: "
-        "https://python.langchain.com/docs/versions/migrating_memory/"
-    ),
-)
-class ConversationSummaryMemory(BaseChatMemory, SummarizerMixin):
-    """Continually summarizes the conversation history.
-
-    The summary is updated after each conversation turn.
-    The implementations returns a summary of the conversation history which
-    can be used to provide context to the model.
-    """
-
-    buffer: str = ""
-    memory_key: str = "history"  #: :meta private:
-
-    @classmethod
-    def from_messages(
-        cls,
-        llm: BaseLanguageModel,
-        chat_memory: BaseChatMessageHistory,
-        *,
-        summarize_step: int = 2,
-        **kwargs: Any,
-    ) -> ConversationSummaryMemory:
-        """Create a ConversationSummaryMemory from a list of messages.
-
-        Args:
-            llm: The language model to use for summarization.
-            chat_memory: The chat history to summarize.
-            summarize_step: Number of messages to summarize at a time.
-            **kwargs: Additional keyword arguments to pass to the class.
-        Returns:
-            An instance of ConversationSummaryMemory with the summarized history.
-        """
-        obj = cls(llm=llm, chat_memory=chat_memory, **kwargs)
-        for i in range(0, len(obj.chat_memory.messages), summarize_step):
-            obj.buffer = obj.predict_new_summary(
-                obj.chat_memory.messages[i : i + summarize_step],
-                obj.buffer,
-            )
-        return obj
-
-    @property
-    def memory_variables(self) -> list[str]:
-        """Will always return list of memory variables.
-
-        :meta private:
-        """
-        return [self.memory_key]
-
-    @override
-    def load_memory_variables(self, inputs: dict[str, Any]) -> dict[str, Any]:
-        """Return history buffer."""
-        if self.return_messages:
-            buffer: Any = [self.summary_message_cls(content=self.buffer)]
-        else:
-            buffer = self.buffer
-        return {self.memory_key: buffer}
-
-    @pre_init
-    def validate_prompt_input_variables(cls, values: dict) -> dict:
-        """Validate that prompt input variables are consistent."""
-        prompt_variables = values["prompt"].input_variables
-        expected_keys = {"summary", "new_lines"}
-        if expected_keys != set(prompt_variables):
-            msg = (
-                "Got unexpected prompt input variables. The prompt expects "
-                f"{prompt_variables}, but it should have {expected_keys}."
-            )
-            raise ValueError(msg)
-        return values
-
-    def save_context(self, inputs: dict[str, Any], outputs: dict[str, str]) -> None:
-        """Save context from this conversation to buffer."""
-        super().save_context(inputs, outputs)
-        self.buffer = self.predict_new_summary(
-            self.chat_memory.messages[-2:],
-            self.buffer,
-        )
-
-    def clear(self) -> None:
-        """Clear memory contents."""
-        super().clear()
-        self.buffer = ""

langchain/memory/summary_buffer.py

@@ -1,151 +0,0 @@
-from typing import Any, Union
-
-from langchain_core._api import deprecated
-from langchain_core.messages import BaseMessage, get_buffer_string
-from langchain_core.utils import pre_init
-from typing_extensions import override
-
-from langchain.memory.chat_memory import BaseChatMemory
-from langchain.memory.summary import SummarizerMixin
-
-
-@deprecated(
-    since="0.3.1",
-    removal="1.0.0",
-    message=(
-        "Please see the migration guide at: "
-        "https://python.langchain.com/docs/versions/migrating_memory/"
-    ),
-)
-class ConversationSummaryBufferMemory(BaseChatMemory, SummarizerMixin):
-    """Buffer with summarizer for storing conversation memory.
-
-    Provides a running summary of the conversation together with the most recent
-    messages in the conversation under the constraint that the total number of
-    tokens in the conversation does not exceed a certain limit.
-    """
-
-    max_token_limit: int = 2000
-    moving_summary_buffer: str = ""
-    memory_key: str = "history"
-
-    @property
-    def buffer(self) -> Union[str, list[BaseMessage]]:
-        """String buffer of memory."""
-        return self.load_memory_variables({})[self.memory_key]
-
-    async def abuffer(self) -> Union[str, list[BaseMessage]]:
-        """Async memory buffer."""
-        memory_variables = await self.aload_memory_variables({})
-        return memory_variables[self.memory_key]
-
-    @property
-    def memory_variables(self) -> list[str]:
-        """Will always return list of memory variables.
-
-        :meta private:
-        """
-        return [self.memory_key]
-
-    @override
-    def load_memory_variables(self, inputs: dict[str, Any]) -> dict[str, Any]:
-        """Return history buffer."""
-        buffer = self.chat_memory.messages
-        if self.moving_summary_buffer != "":
-            first_messages: list[BaseMessage] = [
-                self.summary_message_cls(content=self.moving_summary_buffer),
-            ]
-            buffer = first_messages + buffer
-        if self.return_messages:
-            final_buffer: Any = buffer
-        else:
-            final_buffer = get_buffer_string(
-                buffer,
-                human_prefix=self.human_prefix,
-                ai_prefix=self.ai_prefix,
-            )
-        return {self.memory_key: final_buffer}
-
-    @override
-    async def aload_memory_variables(self, inputs: dict[str, Any]) -> dict[str, Any]:
-        """Asynchronously return key-value pairs given the text input to the chain."""
-        buffer = await self.chat_memory.aget_messages()
-        if self.moving_summary_buffer != "":
-            first_messages: list[BaseMessage] = [
-                self.summary_message_cls(content=self.moving_summary_buffer),
-            ]
-            buffer = first_messages + buffer
-        if self.return_messages:
-            final_buffer: Any = buffer
-        else:
-            final_buffer = get_buffer_string(
-                buffer,
-                human_prefix=self.human_prefix,
-                ai_prefix=self.ai_prefix,
-            )
-        return {self.memory_key: final_buffer}
-
-    @pre_init
-    def validate_prompt_input_variables(cls, values: dict) -> dict:
-        """Validate that prompt input variables are consistent."""
-        prompt_variables = values["prompt"].input_variables
-        expected_keys = {"summary", "new_lines"}
-        if expected_keys != set(prompt_variables):
-            msg = (
-                "Got unexpected prompt input variables. The prompt expects "
-                f"{prompt_variables}, but it should have {expected_keys}."
-            )
-            raise ValueError(msg)
-        return values
-
-    def save_context(self, inputs: dict[str, Any], outputs: dict[str, str]) -> None:
-        """Save context from this conversation to buffer."""
-        super().save_context(inputs, outputs)
-        self.prune()
-
-    async def asave_context(
-        self,
-        inputs: dict[str, Any],
-        outputs: dict[str, str],
-    ) -> None:
-        """Asynchronously save context from this conversation to buffer."""
-        await super().asave_context(inputs, outputs)
-        await self.aprune()
-
-    def prune(self) -> None:
-        """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:
-            pruned_memory = []
-            while curr_buffer_length > self.max_token_limit:
-                pruned_memory.append(buffer.pop(0))
-                curr_buffer_length = self.llm.get_num_tokens_from_messages(buffer)
-            self.moving_summary_buffer = self.predict_new_summary(
-                pruned_memory,
-                self.moving_summary_buffer,
-            )
-
-    async def aprune(self) -> None:
-        """Asynchronously 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:
-            pruned_memory = []
-            while curr_buffer_length > self.max_token_limit:
-                pruned_memory.append(buffer.pop(0))
-                curr_buffer_length = self.llm.get_num_tokens_from_messages(buffer)
-            self.moving_summary_buffer = await self.apredict_new_summary(
-                pruned_memory,
-                self.moving_summary_buffer,
-            )
-
-    def clear(self) -> None:
-        """Clear memory contents."""
-        super().clear()
-        self.moving_summary_buffer = ""
-
-    async def aclear(self) -> None:
-        """Asynchronously clear memory contents."""
-        await super().aclear()
-        self.moving_summary_buffer = ""

langchain/memory/token_buffer.py

@@ -1,74 +0,0 @@
-from typing import Any
-
-from langchain_core._api import deprecated
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.messages import BaseMessage, get_buffer_string
-from typing_extensions import override
-
-from langchain.memory.chat_memory import BaseChatMemory
-
-
-@deprecated(
-    since="0.3.1",
-    removal="1.0.0",
-    message=(
-        "Please see the migration guide at: "
-        "https://python.langchain.com/docs/versions/migrating_memory/"
-    ),
-)
-class ConversationTokenBufferMemory(BaseChatMemory):
-    """Conversation chat memory with token limit.
-
-    Keeps only the most recent messages in the conversation under the constraint
-    that the total number of tokens in the conversation does not exceed a certain limit.
-    """
-
-    human_prefix: str = "Human"
-    ai_prefix: str = "AI"
-    llm: BaseLanguageModel
-    memory_key: str = "history"
-    max_token_limit: int = 2000
-
-    @property
-    def buffer(self) -> Any:
-        """String buffer of memory."""
-        return self.buffer_as_messages if self.return_messages else self.buffer_as_str
-
-    @property
-    def buffer_as_str(self) -> str:
-        """Exposes the buffer as a string in case return_messages is False."""
-        return get_buffer_string(
-            self.chat_memory.messages,
-            human_prefix=self.human_prefix,
-            ai_prefix=self.ai_prefix,
-        )
-
-    @property
-    def buffer_as_messages(self) -> list[BaseMessage]:
-        """Exposes the buffer as a list of messages in case return_messages is True."""
-        return self.chat_memory.messages
-
-    @property
-    def memory_variables(self) -> list[str]:
-        """Will always return list of memory variables.
-
-        :meta private:
-        """
-        return [self.memory_key]
-
-    @override
-    def load_memory_variables(self, inputs: dict[str, Any]) -> dict[str, Any]:
-        """Return history buffer."""
-        return {self.memory_key: self.buffer}
-
-    def save_context(self, inputs: dict[str, Any], outputs: dict[str, str]) -> None:
-        """Save context from this conversation to buffer. Pruned."""
-        super().save_context(inputs, outputs)
-        # 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:
-            pruned_memory = []
-            while curr_buffer_length > self.max_token_limit:
-                pruned_memory.append(buffer.pop(0))
-                curr_buffer_length = self.llm.get_num_tokens_from_messages(buffer)

langchain/memory/utils.py

@@ -1,21 +0,0 @@
-from typing import Any
-
-
-def get_prompt_input_key(inputs: dict[str, Any], memory_variables: list[str]) -> str:
-    """
-    Get the prompt input key.
-
-    Args:
-        inputs: Dict[str, Any]
-        memory_variables: List[str]
-
-    Returns:
-        A prompt input key.
-    """
-    # "stop" is a special key that can be passed as input but is not used to
-    # format the prompt.
-    prompt_input_keys = list(set(inputs).difference([*memory_variables, "stop"]))
-    if len(prompt_input_keys) != 1:
-        msg = f"One input key expected got {prompt_input_keys}"
-        raise ValueError(msg)
-    return prompt_input_keys[0]