langchain 1.0.0a12__py3-none-any.whl → 1.0.4__py3-none-any.whl

langchain/embeddings/cache.py

@@ -1,361 +0,0 @@
-"""Module contains code for a cache backed embedder.
-
-The cache backed embedder is a wrapper around an embedder that caches
-embeddings in a key-value store. The cache is used to avoid recomputing
-embeddings for the same text.
-
-The text is hashed and the hash is used as the key in the cache.
-"""
-
-from __future__ import annotations
-
-import hashlib
-import json
-import uuid
-import warnings
-from typing import TYPE_CHECKING, Literal, cast
-
-from langchain_core.embeddings import Embeddings
-from langchain_core.utils.iter import batch_iterate
-
-from langchain.storage.encoder_backed import EncoderBackedStore
-
-if TYPE_CHECKING:
-    from collections.abc import Callable, Sequence
-
-    from langchain_core.stores import BaseStore, ByteStore
-
-NAMESPACE_UUID = uuid.UUID(int=1985)
-
-
-def _sha1_hash_to_uuid(text: str) -> uuid.UUID:
-    """Return a UUID derived from *text* using SHA-1 (deterministic).
-
-    Deterministic and fast, **but not collision-resistant**.
-
-    A malicious attacker could try to create two different texts that hash to the same
-    UUID. This may not necessarily be an issue in the context of caching embeddings,
-    but new applications should swap this out for a stronger hash function like
-    xxHash, BLAKE2 or SHA-256, which are collision-resistant.
-    """
-    sha1_hex = hashlib.sha1(text.encode("utf-8"), usedforsecurity=False).hexdigest()
-    # Embed the hex string in `uuid5` to obtain a valid UUID.
-    return uuid.uuid5(NAMESPACE_UUID, sha1_hex)
-
-
-def _make_default_key_encoder(namespace: str, algorithm: str) -> Callable[[str], str]:
-    """Create a default key encoder function.
-
-    Args:
-        namespace: Prefix that segregates keys from different embedding models.
-        algorithm:
-           * ``'sha1'`` - fast but not collision-resistant
-           * ``'blake2b'`` - cryptographically strong, faster than SHA-1
-           * ``'sha256'`` - cryptographically strong, slower than SHA-1
-           * ``'sha512'`` - cryptographically strong, slower than SHA-1
-
-    Returns:
-        A function that encodes a key using the specified algorithm.
-    """
-    if algorithm == "sha1":
-        _warn_about_sha1_encoder()
-
-    def _key_encoder(key: str) -> str:
-        """Encode a key using the specified algorithm."""
-        if algorithm == "sha1":
-            return f"{namespace}{_sha1_hash_to_uuid(key)}"
-        if algorithm == "blake2b":
-            return f"{namespace}{hashlib.blake2b(key.encode('utf-8')).hexdigest()}"
-        if algorithm == "sha256":
-            return f"{namespace}{hashlib.sha256(key.encode('utf-8')).hexdigest()}"
-        if algorithm == "sha512":
-            return f"{namespace}{hashlib.sha512(key.encode('utf-8')).hexdigest()}"
-        msg = f"Unsupported algorithm: {algorithm}"
-        raise ValueError(msg)
-
-    return _key_encoder
-
-
-def _value_serializer(value: Sequence[float]) -> bytes:
-    """Serialize a value."""
-    return json.dumps(value).encode()
-
-
-def _value_deserializer(serialized_value: bytes) -> list[float]:
-    """Deserialize a value."""
-    return cast("list[float]", json.loads(serialized_value.decode()))
-
-
-# The warning is global; track emission, so it appears only once.
-_warned_about_sha1: bool = False
-
-
-def _warn_about_sha1_encoder() -> None:
-    """Emit a one-time warning about SHA-1 collision weaknesses."""
-    global _warned_about_sha1  # noqa: PLW0603
-    if not _warned_about_sha1:
-        warnings.warn(
-            "Using default key encoder: SHA-1 is *not* collision-resistant. "
-            "While acceptable for most cache scenarios, a motivated attacker "
-            "can craft two different payloads that map to the same cache key. "
-            "If that risk matters in your environment, supply a stronger "
-            "encoder (e.g. SHA-256 or BLAKE2) via the `key_encoder` argument. "
-            "If you change the key encoder, consider also creating a new cache, "
-            "to avoid (the potential for) collisions with existing keys.",
-            category=UserWarning,
-            stacklevel=2,
-        )
-        _warned_about_sha1 = True
-
-
-class CacheBackedEmbeddings(Embeddings):
-    """Interface for caching results from embedding models.
-
-    The interface allows works with any store that implements
-    the abstract store interface accepting keys of type str and values of list of
-    floats.
-
-    If need be, the interface can be extended to accept other implementations
-    of the value serializer and deserializer, as well as the key encoder.
-
-    Note that by default only document embeddings are cached. To cache query
-    embeddings too, pass in a query_embedding_store to constructor.
-
-    Examples:
-        .. code-block: python
-
-            from langchain.embeddings import CacheBackedEmbeddings
-            from langchain.storage import LocalFileStore
-            from langchain_community.embeddings import OpenAIEmbeddings
-
-            store = LocalFileStore('./my_cache')
-
-            underlying_embedder = OpenAIEmbeddings()
-            embedder = CacheBackedEmbeddings.from_bytes_store(
-                underlying_embedder, store, namespace=underlying_embedder.model
-            )
-
-            # Embedding is computed and cached
-            embeddings = embedder.embed_documents(["hello", "goodbye"])
-
-            # Embeddings are retrieved from the cache, no computation is done
-            embeddings = embedder.embed_documents(["hello", "goodbye"])
-    """
-
-    def __init__(
-        self,
-        underlying_embeddings: Embeddings,
-        document_embedding_store: BaseStore[str, list[float]],
-        *,
-        batch_size: int | None = None,
-        query_embedding_store: BaseStore[str, list[float]] | None = None,
-    ) -> None:
-        """Initialize the embedder.
-
-        Args:
-            underlying_embeddings: the embedder to use for computing embeddings.
-            document_embedding_store: The store to use for caching document embeddings.
-            batch_size: The number of documents to embed between store updates.
-            query_embedding_store: The store to use for caching query embeddings.
-                If ``None``, query embeddings are not cached.
-        """
-        super().__init__()
-        self.document_embedding_store = document_embedding_store
-        self.query_embedding_store = query_embedding_store
-        self.underlying_embeddings = underlying_embeddings
-        self.batch_size = batch_size
-
-    def embed_documents(self, texts: list[str]) -> list[list[float]]:
-        """Embed a list of texts.
-
-        The method first checks the cache for the embeddings.
-        If the embeddings are not found, the method uses the underlying embedder
-        to embed the documents and stores the results in the cache.
-
-        Args:
-            texts: A list of texts to embed.
-
-        Returns:
-            A list of embeddings for the given texts.
-        """
-        vectors: list[list[float] | None] = self.document_embedding_store.mget(
-            texts,
-        )
-        all_missing_indices: list[int] = [i for i, vector in enumerate(vectors) if vector is None]
-
-        for missing_indices in batch_iterate(self.batch_size, all_missing_indices):
-            missing_texts = [texts[i] for i in missing_indices]
-            missing_vectors = self.underlying_embeddings.embed_documents(missing_texts)
-            self.document_embedding_store.mset(
-                list(zip(missing_texts, missing_vectors, strict=False)),
-            )
-            for index, updated_vector in zip(missing_indices, missing_vectors, strict=False):
-                vectors[index] = updated_vector
-
-        return cast(
-            "list[list[float]]",
-            vectors,
-        )  # Nones should have been resolved by now
-
-    async def aembed_documents(self, texts: list[str]) -> list[list[float]]:
-        """Embed a list of texts.
-
-        The method first checks the cache for the embeddings.
-        If the embeddings are not found, the method uses the underlying embedder
-        to embed the documents and stores the results in the cache.
-
-        Args:
-            texts: A list of texts to embed.
-
-        Returns:
-            A list of embeddings for the given texts.
-        """
-        vectors: list[list[float] | None] = await self.document_embedding_store.amget(texts)
-        all_missing_indices: list[int] = [i for i, vector in enumerate(vectors) if vector is None]
-
-        # batch_iterate supports None batch_size which returns all elements at once
-        # as a single batch.
-        for missing_indices in batch_iterate(self.batch_size, all_missing_indices):
-            missing_texts = [texts[i] for i in missing_indices]
-            missing_vectors = await self.underlying_embeddings.aembed_documents(
-                missing_texts,
-            )
-            await self.document_embedding_store.amset(
-                list(zip(missing_texts, missing_vectors, strict=False)),
-            )
-            for index, updated_vector in zip(missing_indices, missing_vectors, strict=False):
-                vectors[index] = updated_vector
-
-        return cast(
-            "list[list[float]]",
-            vectors,
-        )  # Nones should have been resolved by now
-
-    def embed_query(self, text: str) -> list[float]:
-        """Embed query text.
-
-        By default, this method does not cache queries. To enable caching, set the
-        ``cache_query`` parameter to ``True`` when initializing the embedder.
-
-        Args:
-            text: The text to embed.
-
-        Returns:
-            The embedding for the given text.
-        """
-        if not self.query_embedding_store:
-            return self.underlying_embeddings.embed_query(text)
-
-        (cached,) = self.query_embedding_store.mget([text])
-        if cached is not None:
-            return cached
-
-        vector = self.underlying_embeddings.embed_query(text)
-        self.query_embedding_store.mset([(text, vector)])
-        return vector
-
-    async def aembed_query(self, text: str) -> list[float]:
-        """Embed query text.
-
-        By default, this method does not cache queries. To enable caching, set the
-        ``cache_query`` parameter to ``True`` when initializing the embedder.
-
-        Args:
-            text: The text to embed.
-
-        Returns:
-            The embedding for the given text.
-        """
-        if not self.query_embedding_store:
-            return await self.underlying_embeddings.aembed_query(text)
-
-        (cached,) = await self.query_embedding_store.amget([text])
-        if cached is not None:
-            return cached
-
-        vector = await self.underlying_embeddings.aembed_query(text)
-        await self.query_embedding_store.amset([(text, vector)])
-        return vector
-
-    @classmethod
-    def from_bytes_store(
-        cls,
-        underlying_embeddings: Embeddings,
-        document_embedding_cache: ByteStore,
-        *,
-        namespace: str = "",
-        batch_size: int | None = None,
-        query_embedding_cache: bool | ByteStore = False,
-        key_encoder: Callable[[str], str] | Literal["sha1", "blake2b", "sha256", "sha512"] = "sha1",
-    ) -> CacheBackedEmbeddings:
-        """On-ramp that adds the necessary serialization and encoding to the store.
-
-        Args:
-            underlying_embeddings: The embedder to use for embedding.
-            document_embedding_cache: The cache to use for storing document embeddings.
-            namespace: The namespace to use for document cache.
-                This namespace is used to avoid collisions with other caches.
-                For example, set it to the name of the embedding model used.
-            batch_size: The number of documents to embed between store updates.
-            query_embedding_cache: The cache to use for storing query embeddings.
-                True to use the same cache as document embeddings.
-                False to not cache query embeddings.
-            key_encoder: Optional callable to encode keys. If not provided,
-                a default encoder using SHA-1 will be used. SHA-1 is not
-                collision-resistant, and a motivated attacker could craft two
-                different texts that hash to the same cache key.
-
-                New applications should use one of the alternative encoders
-                or provide a custom and strong key encoder function to avoid this risk.
-
-                If you change a key encoder in an existing cache, consider
-                just creating a new cache, to avoid (the potential for)
-                collisions with existing keys or having duplicate keys
-                for the same text in the cache.
-
-        Returns:
-            An instance of CacheBackedEmbeddings that uses the provided cache.
-        """
-        if isinstance(key_encoder, str):
-            key_encoder = _make_default_key_encoder(namespace, key_encoder)
-        elif callable(key_encoder):
-            # If a custom key encoder is provided, it should not be used with a
-            # namespace.
-            # A user can handle namespacing in directly their custom key encoder.
-            if namespace:
-                msg = (
-                    "Do not supply `namespace` when using a custom key_encoder; "
-                    "add any prefixing inside the encoder itself."
-                )
-                raise ValueError(msg)
-        else:
-            msg = (
-                "key_encoder must be either 'blake2b', 'sha1', 'sha256', 'sha512' "
-                "or a callable that encodes keys."
-            )
-            raise ValueError(msg)  # noqa: TRY004
-
-        document_embedding_store = EncoderBackedStore[str, list[float]](
-            document_embedding_cache,
-            key_encoder,
-            _value_serializer,
-            _value_deserializer,
-        )
-        if query_embedding_cache is True:
-            query_embedding_store = document_embedding_store
-        elif query_embedding_cache is False:
-            query_embedding_store = None
-        else:
-            query_embedding_store = EncoderBackedStore[str, list[float]](
-                query_embedding_cache,
-                key_encoder,
-                _value_serializer,
-                _value_deserializer,
-            )
-
-        return cls(
-            underlying_embeddings,
-            document_embedding_store,
-            batch_size=batch_size,
-            query_embedding_store=query_embedding_store,
-        )

langchain/storage/__init__.py

@@ -1,22 +0,0 @@
-"""Implementations of key-value stores and storage helpers.
-
-Module provides implementations of various key-value stores that conform
-to a simple key-value interface.
-
-The primary goal of these storages is to support implementation of caching.
-"""
-
-from langchain_core.stores import (
-    InMemoryByteStore,
-    InMemoryStore,
-    InvalidKeyException,
-)
-
-from langchain.storage.encoder_backed import EncoderBackedStore
-
-__all__ = [
-    "EncoderBackedStore",
-    "InMemoryByteStore",
-    "InMemoryStore",
-    "InvalidKeyException",
-]

langchain/storage/encoder_backed.py

@@ -1,123 +0,0 @@
-"""Encoder-backed store implementation."""
-
-from collections.abc import AsyncIterator, Callable, Iterator, Sequence
-from typing import (
-    Any,
-    TypeVar,
-)
-
-from langchain_core.stores import BaseStore
-
-K = TypeVar("K")
-V = TypeVar("V")
-
-
-class EncoderBackedStore(BaseStore[K, V]):
-    """Wraps a store with key and value encoders/decoders.
-
-    Examples that uses JSON for encoding/decoding:
-
-    .. code-block:: python
-
-        import json
-
-
-        def key_encoder(key: int) -> str:
-            return json.dumps(key)
-
-
-        def value_serializer(value: float) -> str:
-            return json.dumps(value)
-
-
-        def value_deserializer(serialized_value: str) -> float:
-            return json.loads(serialized_value)
-
-
-        # Create an instance of the abstract store
-        abstract_store = MyCustomStore()
-
-        # Create an instance of the encoder-backed store
-        store = EncoderBackedStore(
-            store=abstract_store,
-            key_encoder=key_encoder,
-            value_serializer=value_serializer,
-            value_deserializer=value_deserializer,
-        )
-
-        # Use the encoder-backed store methods
-        store.mset([(1, 3.14), (2, 2.718)])
-        values = store.mget([1, 2])  # Retrieves [3.14, 2.718]
-        store.mdelete([1, 2])  # Deletes the keys 1 and 2
-
-    """
-
-    def __init__(
-        self,
-        store: BaseStore[str, Any],
-        key_encoder: Callable[[K], str],
-        value_serializer: Callable[[V], bytes],
-        value_deserializer: Callable[[Any], V],
-    ) -> None:
-        """Initialize an EncodedStore."""
-        self.store = store
-        self.key_encoder = key_encoder
-        self.value_serializer = value_serializer
-        self.value_deserializer = value_deserializer
-
-    def mget(self, keys: Sequence[K]) -> list[V | None]:
-        """Get the values associated with the given keys."""
-        encoded_keys: list[str] = [self.key_encoder(key) for key in keys]
-        values = self.store.mget(encoded_keys)
-        return [self.value_deserializer(value) if value is not None else value for value in values]
-
-    async def amget(self, keys: Sequence[K]) -> list[V | None]:
-        """Get the values associated with the given keys."""
-        encoded_keys: list[str] = [self.key_encoder(key) for key in keys]
-        values = await self.store.amget(encoded_keys)
-        return [self.value_deserializer(value) if value is not None else value for value in values]
-
-    def mset(self, key_value_pairs: Sequence[tuple[K, V]]) -> None:
-        """Set the values for the given keys."""
-        encoded_pairs = [
-            (self.key_encoder(key), self.value_serializer(value)) for key, value in key_value_pairs
-        ]
-        self.store.mset(encoded_pairs)
-
-    async def amset(self, key_value_pairs: Sequence[tuple[K, V]]) -> None:
-        """Set the values for the given keys."""
-        encoded_pairs = [
-            (self.key_encoder(key), self.value_serializer(value)) for key, value in key_value_pairs
-        ]
-        await self.store.amset(encoded_pairs)
-
-    def mdelete(self, keys: Sequence[K]) -> None:
-        """Delete the given keys and their associated values."""
-        encoded_keys = [self.key_encoder(key) for key in keys]
-        self.store.mdelete(encoded_keys)
-
-    async def amdelete(self, keys: Sequence[K]) -> None:
-        """Delete the given keys and their associated values."""
-        encoded_keys = [self.key_encoder(key) for key in keys]
-        await self.store.amdelete(encoded_keys)
-
-    def yield_keys(
-        self,
-        *,
-        prefix: str | None = None,
-    ) -> Iterator[K] | Iterator[str]:
-        """Get an iterator over keys that match the given prefix."""
-        # For the time being this does not return K, but str
-        # it's for debugging purposes. Should fix this.
-        yield from self.store.yield_keys(prefix=prefix)
-
-    async def ayield_keys(
-        self,
-        *,
-        prefix: str | None = None,
-    ) -> AsyncIterator[K] | AsyncIterator[str]:
-        """Get an iterator over keys that match the given prefix."""
-        # For the time being this does not return K, but str
-        # it's for debugging purposes. Should fix this.
-        async for key in self.store.ayield_keys(prefix=prefix):
-            yield key

langchain/storage/exceptions.py

@@ -1,5 +0,0 @@
-"""Store exceptions."""
-
-from langchain_core.stores import InvalidKeyException
-
-__all__ = ["InvalidKeyException"]

langchain/storage/in_memory.py

@@ -1,13 +0,0 @@
-"""In memory store that is not thread safe and has no eviction policy.
-
-This is a simple implementation of the BaseStore using a dictionary that is useful
-primarily for unit testing purposes.
-"""
-
-from langchain_core.stores import InMemoryBaseStore, InMemoryByteStore, InMemoryStore
-
-__all__ = [
-    "InMemoryBaseStore",
-    "InMemoryByteStore",
-    "InMemoryStore",
-]

langchain-1.0.0a12.dist-info/METADATA

@@ -1,122 +0,0 @@
-Metadata-Version: 2.4
-Name: langchain
-Version: 1.0.0a12
-Summary: Building applications with LLMs through composability
-Project-URL: Source Code, https://github.com/langchain-ai/langchain/tree/master/libs/langchain
-Project-URL: Release Notes, https://github.com/langchain-ai/langchain/releases?q=tag%3A%22langchain%3D%3D0%22&expanded=true
-Project-URL: repository, https://github.com/langchain-ai/langchain
-License: MIT
-License-File: LICENSE
-Requires-Python: <4.0.0,>=3.10.0
-Requires-Dist: langchain-core<2.0.0,>=1.0.0a6
-Requires-Dist: langgraph<2.0.0,>=1.0.0a4
-Requires-Dist: pydantic<3.0.0,>=2.7.4
-Provides-Extra: anthropic
-Requires-Dist: langchain-anthropic; extra == 'anthropic'
-Provides-Extra: aws
-Requires-Dist: langchain-aws; extra == 'aws'
-Provides-Extra: community
-Requires-Dist: langchain-community; extra == 'community'
-Provides-Extra: deepseek
-Requires-Dist: langchain-deepseek; extra == 'deepseek'
-Provides-Extra: fireworks
-Requires-Dist: langchain-fireworks; extra == 'fireworks'
-Provides-Extra: google-genai
-Requires-Dist: langchain-google-genai; extra == 'google-genai'
-Provides-Extra: google-vertexai
-Requires-Dist: langchain-google-vertexai; extra == 'google-vertexai'
-Provides-Extra: groq
-Requires-Dist: langchain-groq; extra == 'groq'
-Provides-Extra: mistralai
-Requires-Dist: langchain-mistralai; extra == 'mistralai'
-Provides-Extra: ollama
-Requires-Dist: langchain-ollama; extra == 'ollama'
-Provides-Extra: openai
-Requires-Dist: langchain-openai; extra == 'openai'
-Provides-Extra: perplexity
-Requires-Dist: langchain-perplexity; extra == 'perplexity'
-Provides-Extra: together
-Requires-Dist: langchain-together; extra == 'together'
-Provides-Extra: xai
-Requires-Dist: langchain-xai; extra == 'xai'
-Description-Content-Type: text/markdown
-
-# 🦜️🔗 LangChain
-
-⚡ Building applications with LLMs through composability ⚡
-
-[![PyPI - License](https://img.shields.io/pypi/l/langchain?style=flat-square)](https://opensource.org/licenses/MIT)
-[![PyPI - Downloads](https://img.shields.io/pepy/dt/langchain)](https://pypistats.org/packages/langchain)
-[![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchainai.svg?style=social&label=Follow%20%40LangChainAI)](https://twitter.com/langchainai)
-
-Looking for the JS/TS version? Check out [LangChain.js](https://github.com/langchain-ai/langchainjs).
-
-To help you ship LangChain apps to production faster, check out [LangSmith](https://smith.langchain.com).
-[LangSmith](https://smith.langchain.com) is a unified developer platform for building, testing, and monitoring LLM applications.
-
-## Quick Install
-
-`pip install langchain`
-
-## 🤔 What is this?
-
-Large language models (LLMs) are emerging as a transformative technology, enabling developers to build applications that they previously could not. However, using these LLMs in isolation is often insufficient for creating a truly powerful app - the real power comes when you can combine them with other sources of computation or knowledge.
-
-This library aims to assist in the development of those types of applications. Common examples of these applications include:
-
-**❓ Question answering with RAG**
-
-- [Documentation](https://python.langchain.com/docs/tutorials/rag/)
-- End-to-end Example: [Chat LangChain](https://chat.langchain.com) and [repo](https://github.com/langchain-ai/chat-langchain)
-
-**🧱 Extracting structured output**
-
-- [Documentation](https://python.langchain.com/docs/tutorials/extraction/)
-- End-to-end Example: [SQL Llama2 Template](https://github.com/langchain-ai/langchain-extract/)
-
-**🤖 Chatbots**
-
-- [Documentation](https://python.langchain.com/docs/tutorials/chatbot/)
-- End-to-end Example: [Web LangChain (web researcher chatbot)](https://weblangchain.vercel.app) and [repo](https://github.com/langchain-ai/weblangchain)
-
-## 📖 Documentation
-
-Please see [our full documentation](https://python.langchain.com) on:
-
-- Getting started (installation, setting up the environment, simple examples)
-- How-To examples (demos, integrations, helper functions)
-- Reference (full API docs)
-- Resources (high-level explanation of core concepts)
-
-## 🚀 What can this help with?
-
-There are five main areas that LangChain is designed to help with.
-These are, in increasing order of complexity:
-
-**🤖 Agents:**
-
-Agents involve an LLM making decisions about which Actions to take, taking that Action, seeing an Observation, and repeating that until done. LangChain provides a standard interface for agents, a selection of agents to choose from, and examples of end-to-end agents.
-
-**📚 Retrieval Augmented Generation:**
-
-Retrieval Augmented Generation involves specific types of chains that first interact with an external data source to fetch data for use in the generation step. Examples include summarization of long pieces of text and question/answering over specific data sources.
-
-**🧐 Evaluation:**
-
-Generative models are notoriously hard to evaluate with traditional metrics. One new way of evaluating them is using language models themselves to do the evaluation. LangChain provides some prompts/chains for assisting in this.
-
-**📃 Models and Prompts:**
-
-This includes prompt management, prompt optimization, a generic interface for all LLMs, and common utilities for working with chat models and LLMs.
-
-**🔗 Chains:**
-
-Chains go beyond a single LLM call and involve sequences of calls (whether to an LLM or a different utility). LangChain provides a standard interface for chains, lots of integrations with other tools, and end-to-end chains for common applications.
-
-For more information on these concepts, please see our [full documentation](https://python.langchain.com).
-
-## 💁 Contributing
-
-As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.
-
-For detailed information on how to contribute, see the [Contributing Guide](https://python.langchain.com/docs/contributing/).