langchain 1.0.0a12__py3-none-any.whl → 1.0.0a14__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/RECORD

@@ -1,43 +0,0 @@
-langchain/__init__.py,sha256=r-dYWvMexpt3NwZEBukjX-wFF7i2fNMhSOW4Lry-rnQ,64
-langchain/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langchain/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langchain/_internal/_documents.py,sha256=uQcKc1cslujQzmP1yiyN6Z371BsOkkrZ4bVidsVvgs0,1044
-langchain/_internal/_lazy_import.py,sha256=S_iSAxGvW7lVcUQYgi45KG8XhWZzkORsZ_olPMZPlqU,1258
-langchain/_internal/_prompts.py,sha256=Ldu09Vj04yO9IHssbYps19sw_7uYOm_biXTF8hN6I9M,5910
-langchain/_internal/_typing.py,sha256=T3Nl8oi_SSZ1YMIxNwZm_6TJsiRAiYYAm-dSznGog84,1656
-langchain/_internal/_utils.py,sha256=lG8X9muiRAWtQjRPudq-1x-wHbk0J3spu_rYZckVdYs,251
-langchain/agents/__init__.py,sha256=x85V7MqddVSrraoirGHplPMzEz9Lha-vL9fKjXCS7lA,258
-langchain/agents/factory.py,sha256=n7TFqCy3iqxFnAcHeFaPKd-RPOCw10q3CmkfC_JJnBA,46906
-langchain/agents/structured_output.py,sha256=msf-ClqDnMfJ-oGHqjwEyth860tMnx58GLTvqJijqg8,13686
-langchain/agents/_internal/__init__.py,sha256=5nNBeaeQIvv9IOQjY4_aNW8pffWzMXQgi0b6Nx-WghM,37
-langchain/agents/_internal/_typing.py,sha256=JoWa-KL5uLNeq6yrm56wnIvhDeFnCt2fTzgUcj5zWy4,270
-langchain/agents/middleware/__init__.py,sha256=noyjY-BLoLD7Qw7exk6IikqgKadrvOUr9T_839fOIgs,1455
-langchain/agents/middleware/context_editing.py,sha256=VjInHbeSpkmwlwjN2x2xL9CQu11KodpEDGNo3xHrChw,7752
-langchain/agents/middleware/human_in_the_loop.py,sha256=nsEvBQzJZdtmeOXzqc7VZ_3OAh9DvIdGm9KQIrxhWfo,12004
-langchain/agents/middleware/model_call_limit.py,sha256=Dm_cHeH1Kkci8XdCb44Vtlaft2f1oH7DU2MexZXm4ew,6699
-langchain/agents/middleware/model_fallback.py,sha256=Zc0ZSwwoH9tRBBC-V2Zicjc157yD1eDXybzzLCHq6D4,3390
-langchain/agents/middleware/pii.py,sha256=7uh7Zkr_hjrX2xn9SW1B-Pb3eJQKHHAXK828y0rF9zw,24871
-langchain/agents/middleware/planning.py,sha256=UF4YCSC4rWOuXidmZ7GyH_aKmiN0M7_GL7J0YTqPmf8,9287
-langchain/agents/middleware/prompt_caching.py,sha256=QRIH-2GH2fTJW_slLDCTUJA5pL-prQa9Qil4XZq1YaI,3191
-langchain/agents/middleware/summarization.py,sha256=-Jwr6QD0TKCZbnqzQ5CmgKAI-3eEtm615Trw5lq5E7k,10327
-langchain/agents/middleware/tool_call_limit.py,sha256=M9sa5Fpmf9t-n-cxtdJjFWSBh3FiyypeI09cXDAn2u0,9719
-langchain/agents/middleware/tool_selection.py,sha256=leuQlO7C7pVXWzwLpkKqynPUeICnbCHsdkx9m2Jx4cM,11534
-langchain/agents/middleware/types.py,sha256=SnzoZoAg0z6ZFkDuSCnnoFFcE7nBrU7khLnHSeZGpcs,39042
-langchain/chat_models/__init__.py,sha256=PTq9qskQEbqXYAcUUxUXDsugOcwISgFhv4w40JgkbgU,181
-langchain/chat_models/base.py,sha256=sUXo0oSPupVBIOhHIGoKs-XG3-30u2I213S3_4XDzoQ,34917
-langchain/documents/__init__.py,sha256=DjuBCy1TQbem4Vz8SsCcGAbZeFwW5KgGPvDrA8e9oGA,94
-langchain/embeddings/__init__.py,sha256=sJZEfZ4ovEFU5JJnoVNCJIjtSCLT1w9r9uFw1hieRZ8,269
-langchain/embeddings/base.py,sha256=AM75UjkcYU0gJ6-Xtgf67QBq5fA3k_sz0kVaxiQjR7M,7386
-langchain/embeddings/cache.py,sha256=vHuwhHkzeQMDF6F_rcGk3RolMde7TVyd-ladeFiC-TM,14334
-langchain/messages/__init__.py,sha256=5WgGeiPVK9YIFjx-5m4hVxvg_eo7SC7NqUlwJci18W0,517
-langchain/rate_limiters/__init__.py,sha256=5490xUNhet37N2nX6kbJlDgf8u1DX-C1Cs_r7etXn8A,351
-langchain/storage/__init__.py,sha256=cvxc63N2nluqyVc7d9MeAj5mmO2iYl3GhcxMCpmqjUk,533
-langchain/storage/encoder_backed.py,sha256=4h_4ZgP_B9p1lwVMNdBgpEIC7UDAp--ncp9wm4exmF0,4266
-langchain/storage/exceptions.py,sha256=Fl_8tON3KmByBKwXtno5WSj0-c2RiZxnhw3gv5aS2T8,114
-langchain/storage/in_memory.py,sha256=ozrmu0EtaJJVSAzK_u7nzxWpr9OOscWkANHSg-qIVYQ,369
-langchain/tools/__init__.py,sha256=tWlUqT7jrnf1ouhMctuUkaYBWEuOPD3JQX4Y8uTHk5w,405
-langchain/tools/tool_node.py,sha256=wDJr_LTCN295GrjZi1iKvu_xYj05nbeanqo78jNJaDU,46514
-langchain-1.0.0a12.dist-info/METADATA,sha256=oKxFoU8_xPZNRc1jm3Y3YLlxdiQ5TbQ_hSDbaol10Ps,5987
-langchain-1.0.0a12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langchain-1.0.0a12.dist-info/licenses/LICENSE,sha256=TsZ-TKbmch26hJssqCJhWXyGph7iFLvyFBYAa3stBHg,1067
-langchain-1.0.0a12.dist-info/RECORD,,