langchain 0.3.27__py3-none-any.whl → 1.0.0__py3-none-any.whl

langchain/memory/vectorstore.py

@@ -1,120 +0,0 @@
-"""Class for a VectorStore-backed memory object."""
-
-from collections.abc import Sequence
-from typing import Any, Optional, Union
-
-from langchain_core._api import deprecated
-from langchain_core.documents import Document
-from langchain_core.memory import BaseMemory
-from langchain_core.vectorstores import VectorStoreRetriever
-from pydantic import Field
-
-from langchain.memory.utils import get_prompt_input_key
-
-
-@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 VectorStoreRetrieverMemory(BaseMemory):
-    """Store the conversation history in a vector store and retrieves the relevant
-    parts of past conversation based on the input.
-    """
-
-    retriever: VectorStoreRetriever = Field(exclude=True)
-    """VectorStoreRetriever object to connect to."""
-
-    memory_key: str = "history"  #: :meta private:
-    """Key name to locate the memories in the result of load_memory_variables."""
-
-    input_key: Optional[str] = None
-    """Key name to index the inputs to load_memory_variables."""
-
-    return_docs: bool = False
-    """Whether or not to return the result of querying the database directly."""
-
-    exclude_input_keys: Sequence[str] = Field(default_factory=tuple)
-    """Input keys to exclude in addition to memory key when constructing the document"""
-
-    @property
-    def memory_variables(self) -> list[str]:
-        """The list of keys emitted from the load_memory_variables method."""
-        return [self.memory_key]
-
-    def _get_prompt_input_key(self, inputs: dict[str, Any]) -> str:
-        """Get the input key for the prompt."""
-        if self.input_key is None:
-            return get_prompt_input_key(inputs, self.memory_variables)
-        return self.input_key
-
-    def _documents_to_memory_variables(
-        self,
-        docs: list[Document],
-    ) -> dict[str, Union[list[Document], str]]:
-        result: Union[list[Document], str]
-        if not self.return_docs:
-            result = "\n".join([doc.page_content for doc in docs])
-        else:
-            result = docs
-        return {self.memory_key: result}
-
-    def load_memory_variables(
-        self,
-        inputs: dict[str, Any],
-    ) -> dict[str, Union[list[Document], str]]:
-        """Return history buffer."""
-        input_key = self._get_prompt_input_key(inputs)
-        query = inputs[input_key]
-        docs = self.retriever.invoke(query)
-        return self._documents_to_memory_variables(docs)
-
-    async def aload_memory_variables(
-        self,
-        inputs: dict[str, Any],
-    ) -> dict[str, Union[list[Document], str]]:
-        """Return history buffer."""
-        input_key = self._get_prompt_input_key(inputs)
-        query = inputs[input_key]
-        docs = await self.retriever.ainvoke(query)
-        return self._documents_to_memory_variables(docs)
-
-    def _form_documents(
-        self,
-        inputs: dict[str, Any],
-        outputs: dict[str, str],
-    ) -> list[Document]:
-        """Format context from this conversation to buffer."""
-        # Each document should only include the current turn, not the chat history
-        exclude = set(self.exclude_input_keys)
-        exclude.add(self.memory_key)
-        filtered_inputs = {k: v for k, v in inputs.items() if k not in exclude}
-        texts = [
-            f"{k}: {v}"
-            for k, v in list(filtered_inputs.items()) + list(outputs.items())
-        ]
-        page_content = "\n".join(texts)
-        return [Document(page_content=page_content)]
-
-    def save_context(self, inputs: dict[str, Any], outputs: dict[str, str]) -> None:
-        """Save context from this conversation to buffer."""
-        documents = self._form_documents(inputs, outputs)
-        self.retriever.add_documents(documents)
-
-    async def asave_context(
-        self,
-        inputs: dict[str, Any],
-        outputs: dict[str, str],
-    ) -> None:
-        """Save context from this conversation to buffer."""
-        documents = self._form_documents(inputs, outputs)
-        await self.retriever.aadd_documents(documents)
-
-    def clear(self) -> None:
-        """Nothing to clear."""
-
-    async def aclear(self) -> None:
-        """Nothing to clear."""

langchain/memory/vectorstore_token_buffer_memory.py

@@ -1,184 +0,0 @@
-"""
-Class for a conversation memory buffer with older messages stored in a vectorstore .
-
-This implements 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
-
-from langchain_core.messages import BaseMessage
-from langchain_core.prompts.chat import SystemMessagePromptTemplate
-from langchain_core.vectorstores import VectorStoreRetriever
-from pydantic import Field, PrivateAttr
-
-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_chroma 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)  # type: ignore[assignment]
-    _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> {input_.content!s}"},
-                {"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/memory/zep_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.zep_memory import ZepMemory
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {"ZepMemory": "langchain_community.memory.zep_memory"}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "ZepMemory",
-]

langchain/model_laboratory.py

@@ -1,99 +0,0 @@
-"""Experiment with different models."""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-from typing import Optional
-
-from langchain_core.language_models.llms import BaseLLM
-from langchain_core.prompts.prompt import PromptTemplate
-from langchain_core.utils.input import get_color_mapping, print_text
-
-from langchain.chains.base import Chain
-from langchain.chains.llm import LLMChain
-
-
-class ModelLaboratory:
-    """A utility to experiment with and compare the performance of different models."""
-
-    def __init__(self, chains: Sequence[Chain], names: Optional[list[str]] = None):
-        """Initialize the ModelLaboratory with chains to experiment with.
-
-        Args:
-            chains (Sequence[Chain]): A sequence of chains to experiment with.
-            Each chain must have exactly one input and one output variable.
-        names (Optional[List[str]]): Optional list of names corresponding to each chain.
-            If provided, its length must match the number of chains.
-
-
-        Raises:
-            ValueError: If any chain is not an instance of `Chain`.
-            ValueError: If a chain does not have exactly one input variable.
-            ValueError: If a chain does not have exactly one output variable.
-            ValueError: If the length of `names` does not match the number of chains.
-        """
-        for chain in chains:
-            if not isinstance(chain, Chain):
-                msg = (
-                    "ModelLaboratory should now be initialized with Chains. "
-                    "If you want to initialize with LLMs, use the `from_llms` method "
-                    "instead (`ModelLaboratory.from_llms(...)`)"
-                )
-                raise ValueError(msg)  # noqa: TRY004
-            if len(chain.input_keys) != 1:
-                msg = (
-                    "Currently only support chains with one input variable, "
-                    f"got {chain.input_keys}"
-                )
-                raise ValueError(msg)
-            if len(chain.output_keys) != 1:
-                msg = (
-                    "Currently only support chains with one output variable, "
-                    f"got {chain.output_keys}"
-                )
-        if names is not None and len(names) != len(chains):
-            msg = "Length of chains does not match length of names."
-            raise ValueError(msg)
-        self.chains = chains
-        chain_range = [str(i) for i in range(len(self.chains))]
-        self.chain_colors = get_color_mapping(chain_range)
-        self.names = names
-
-    @classmethod
-    def from_llms(
-        cls,
-        llms: list[BaseLLM],
-        prompt: Optional[PromptTemplate] = None,
-    ) -> ModelLaboratory:
-        """Initialize the ModelLaboratory with LLMs and an optional prompt.
-
-        Args:
-            llms (List[BaseLLM]): A list of LLMs to experiment with.
-            prompt (Optional[PromptTemplate]): An optional prompt to use with the LLMs.
-                If provided, the prompt must contain exactly one input variable.
-
-        Returns:
-            ModelLaboratory: An instance of `ModelLaboratory` initialized with LLMs.
-        """
-        if prompt is None:
-            prompt = PromptTemplate(input_variables=["_input"], template="{_input}")
-        chains = [LLMChain(llm=llm, prompt=prompt) for llm in llms]
-        names = [str(llm) for llm in llms]
-        return cls(chains, names=names)
-
-    def compare(self, text: str) -> None:
-        """Compare model outputs on an input text.
-
-        If a prompt was provided with starting the laboratory, then this text will be
-        fed into the prompt. If no prompt was provided, then the input text is the
-        entire prompt.
-
-        Args:
-            text: input text to run all models on.
-        """
-        print(f"\033[1mInput:\033[0m\n{text}\n")  # noqa: T201
-        for i, chain in enumerate(self.chains):
-            name = self.names[i] if self.names is not None else str(chain)
-            print_text(name, end="\n")
-            output = chain.run(text)
-            print_text(output, color=self.chain_colors[str(i)], end="\n\n")

langchain/output_parsers/__init__.py

@@ -1,87 +0,0 @@
-"""**OutputParser** classes parse the output of an LLM call.
-
-**Class hierarchy:**
-
-.. code-block::
-
-    BaseLLMOutputParser --> BaseOutputParser --> <name>OutputParser  # ListOutputParser, PydanticOutputParser
-
-**Main helpers:**
-
-.. code-block::
-
-    Serializable, Generation, PromptValue
-"""  # noqa: E501
-
-from typing import TYPE_CHECKING, Any
-
-from langchain_core.output_parsers import (
-    CommaSeparatedListOutputParser,
-    ListOutputParser,
-    MarkdownListOutputParser,
-    NumberedListOutputParser,
-    PydanticOutputParser,
-    XMLOutputParser,
-)
-from langchain_core.output_parsers.openai_tools import (
-    JsonOutputKeyToolsParser,
-    JsonOutputToolsParser,
-    PydanticToolsParser,
-)
-
-from langchain._api import create_importer
-from langchain.output_parsers.boolean import BooleanOutputParser
-from langchain.output_parsers.combining import CombiningOutputParser
-from langchain.output_parsers.datetime import DatetimeOutputParser
-from langchain.output_parsers.enum import EnumOutputParser
-from langchain.output_parsers.fix import OutputFixingParser
-from langchain.output_parsers.pandas_dataframe import PandasDataFrameOutputParser
-from langchain.output_parsers.regex import RegexParser
-from langchain.output_parsers.regex_dict import RegexDictParser
-from langchain.output_parsers.retry import RetryOutputParser, RetryWithErrorOutputParser
-from langchain.output_parsers.structured import ResponseSchema, StructuredOutputParser
-from langchain.output_parsers.yaml import YamlOutputParser
-
-if TYPE_CHECKING:
-    from langchain_community.output_parsers.rail_parser import GuardrailsOutputParser
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "GuardrailsOutputParser": "langchain_community.output_parsers.rail_parser",
-}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "BooleanOutputParser",
-    "CombiningOutputParser",
-    "CommaSeparatedListOutputParser",
-    "DatetimeOutputParser",
-    "EnumOutputParser",
-    "GuardrailsOutputParser",
-    "JsonOutputKeyToolsParser",
-    "JsonOutputToolsParser",
-    "ListOutputParser",
-    "MarkdownListOutputParser",
-    "NumberedListOutputParser",
-    "OutputFixingParser",
-    "PandasDataFrameOutputParser",
-    "PydanticOutputParser",
-    "PydanticToolsParser",
-    "RegexDictParser",
-    "RegexParser",
-    "ResponseSchema",
-    "RetryOutputParser",
-    "RetryWithErrorOutputParser",
-    "StructuredOutputParser",
-    "XMLOutputParser",
-    "YamlOutputParser",
-]

langchain/output_parsers/boolean.py

@@ -1,54 +0,0 @@
-import re
-
-from langchain_core.output_parsers import BaseOutputParser
-
-
-class BooleanOutputParser(BaseOutputParser[bool]):
-    """Parse the output of an LLM call to a boolean."""
-
-    true_val: str = "YES"
-    """The string value that should be parsed as True."""
-    false_val: str = "NO"
-    """The string value that should be parsed as False."""
-
-    def parse(self, text: str) -> bool:
-        """Parse the output of an LLM call to a boolean.
-
-        Args:
-            text: output of a language model
-
-        Returns:
-            boolean
-        """
-        regexp = rf"\b({self.true_val}|{self.false_val})\b"
-
-        truthy = {
-            val.upper()
-            for val in re.findall(regexp, text, flags=re.IGNORECASE | re.MULTILINE)
-        }
-        if self.true_val.upper() in truthy:
-            if self.false_val.upper() in truthy:
-                msg = (
-                    f"Ambiguous response. Both {self.true_val} and {self.false_val} "
-                    f"in received: {text}."
-                )
-                raise ValueError(msg)
-            return True
-        if self.false_val.upper() in truthy:
-            if self.true_val.upper() in truthy:
-                msg = (
-                    f"Ambiguous response. Both {self.true_val} and {self.false_val} "
-                    f"in received: {text}."
-                )
-                raise ValueError(msg)
-            return False
-        msg = (
-            f"BooleanOutputParser expected output value to include either "
-            f"{self.true_val} or {self.false_val}. Received {text}."
-        )
-        raise ValueError(msg)
-
-    @property
-    def _type(self) -> str:
-        """Snake-case string identifier for an output parser type."""
-        return "boolean_output_parser"

langchain/output_parsers/combining.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from langchain_core.output_parsers import BaseOutputParser
-from langchain_core.utils import pre_init
-
-_MIN_PARSERS = 2
-
-
-class CombiningOutputParser(BaseOutputParser[dict[str, Any]]):
-    """Combine multiple output parsers into one."""
-
-    parsers: list[BaseOutputParser]
-
-    @classmethod
-    def is_lc_serializable(cls) -> bool:
-        return True
-
-    @pre_init
-    def validate_parsers(cls, values: dict[str, Any]) -> dict[str, Any]:
-        """Validate the parsers."""
-        parsers = values["parsers"]
-        if len(parsers) < _MIN_PARSERS:
-            msg = "Must have at least two parsers"
-            raise ValueError(msg)
-        for parser in parsers:
-            if parser._type == "combining":
-                msg = "Cannot nest combining parsers"
-                raise ValueError(msg)
-            if parser._type == "list":
-                msg = "Cannot combine list parsers"
-                raise ValueError(msg)
-        return values
-
-    @property
-    def _type(self) -> str:
-        """Return the type key."""
-        return "combining"
-
-    def get_format_instructions(self) -> str:
-        """Instructions on how the LLM output should be formatted."""
-
-        initial = f"For your first output: {self.parsers[0].get_format_instructions()}"
-        subsequent = "\n".join(
-            f"Complete that output fully. Then produce another output, separated by two newline characters: {p.get_format_instructions()}"  # noqa: E501
-            for p in self.parsers[1:]
-        )
-        return f"{initial}\n{subsequent}"
-
-    def parse(self, text: str) -> dict[str, Any]:
-        """Parse the output of an LLM call."""
-        texts = text.split("\n\n")
-        output = {}
-        for txt, parser in zip(texts, self.parsers):
-            output.update(parser.parse(txt.strip()))
-        return output

langchain/output_parsers/datetime.py

@@ -1,58 +0,0 @@
-from datetime import datetime, timedelta, timezone
-
-from langchain_core.exceptions import OutputParserException
-from langchain_core.output_parsers import BaseOutputParser
-from langchain_core.utils import comma_list
-
-
-class DatetimeOutputParser(BaseOutputParser[datetime]):
-    """Parse the output of an LLM call to a datetime."""
-
-    format: str = "%Y-%m-%dT%H:%M:%S.%fZ"
-    """The string value that is used as the datetime format.
-
-    Update this to match the desired datetime format for your application.
-    """
-
-    def get_format_instructions(self) -> str:
-        """Returns the format instructions for the given format."""
-        if self.format == "%Y-%m-%dT%H:%M:%S.%fZ":
-            examples = comma_list(
-                [
-                    "2023-07-04T14:30:00.000000Z",
-                    "1999-12-31T23:59:59.999999Z",
-                    "2025-01-01T00:00:00.000000Z",
-                ],
-            )
-        else:
-            try:
-                now = datetime.now(tz=timezone.utc)
-                examples = comma_list(
-                    [
-                        now.strftime(self.format),
-                        (now.replace(year=now.year - 1)).strftime(self.format),
-                        (now - timedelta(days=1)).strftime(self.format),
-                    ],
-                )
-            except ValueError:
-                # Fallback if the format is very unusual
-                examples = f"e.g., a valid string in the format {self.format}"
-
-        return (
-            f"Write a datetime string that matches the "
-            f"following pattern: '{self.format}'.\n\n"
-            f"Examples: {examples}\n\n"
-            f"Return ONLY this string, no other words!"
-        )
-
-    def parse(self, response: str) -> datetime:
-        """Parse a string into a datetime object."""
-        try:
-            return datetime.strptime(response.strip(), self.format)  # noqa: DTZ007
-        except ValueError as e:
-            msg = f"Could not parse datetime string: {response}"
-            raise OutputParserException(msg) from e
-
-    @property
-    def _type(self) -> str:
-        return "datetime"