_cosine_distance() — langchain Function Reference

Architecture documentation for the _cosine_distance() function in base.py from the langchain codebase.

Function python LangChainCore LanguageModelBase calls 2

Entity Profile

LangChainCore→ LanguageModelBase→ _cosine_distance() — langchain Function Reference

Dependency Diagram

graph TD
  15e096ed_4332_85a8_f3e8_1f7f50a320c2["_cosine_distance()"]
  dc2d52f5_736c_0ec2_ad57_0e2fdaa94e04["_EmbeddingDistanceChainMixin"]
  15e096ed_4332_85a8_f3e8_1f7f50a320c2 -->|defined in| dc2d52f5_736c_0ec2_ad57_0e2fdaa94e04
  91b8ba41_75bf_8afd_e893_d85d055226da["_check_numpy()"]
  15e096ed_4332_85a8_f3e8_1f7f50a320c2 -->|calls| 91b8ba41_75bf_8afd_e893_d85d055226da
  caa53c2b_01ef_7204_a5e6_ad683c86dbd2["_import_numpy()"]
  15e096ed_4332_85a8_f3e8_1f7f50a320c2 -->|calls| caa53c2b_01ef_7204_a5e6_ad683c86dbd2
  style 15e096ed_4332_85a8_f3e8_1f7f50a320c2 fill:#6366f1,stroke:#818cf8,color:#fff

Relationship Graph

Source Code

libs/langchain/langchain_classic/evaluation/embedding_distance/base.py lines 193–238

    def _cosine_distance(a: Any, b: Any) -> Any:
        """Compute the cosine distance between two vectors.

        Args:
            a (np.ndarray): The first vector.
            b (np.ndarray): The second vector.

        Returns:
            np.ndarray: The cosine distance.
        """
        try:
            from langchain_core.vectorstores.utils import _cosine_similarity

            return 1.0 - _cosine_similarity(a, b)
        except ImportError:
            # Fallback to scipy if available
            try:
                from scipy.spatial.distance import cosine

                return cosine(a.flatten(), b.flatten())
            except ImportError:
                # Pure numpy fallback
                if _check_numpy():
                    np = _import_numpy()
                    a_flat = a.flatten()
                    b_flat = b.flatten()
                    dot_product = np.dot(a_flat, b_flat)
                    norm_a = np.linalg.norm(a_flat)
                    norm_b = np.linalg.norm(b_flat)
                    if norm_a == 0 or norm_b == 0:
                        return 0.0
                    return 1.0 - (dot_product / (norm_a * norm_b))
                # Pure Python implementation
                a_flat = a if hasattr(a, "__len__") else [a]
                b_flat = b if hasattr(b, "__len__") else [b]
                if hasattr(a, "flatten"):
                    a_flat = a.flatten()
                if hasattr(b, "flatten"):
                    b_flat = b.flatten()

                dot_product = sum(x * y for x, y in zip(a_flat, b_flat, strict=False))
                norm_a = sum(x * x for x in a_flat) ** 0.5
                norm_b = sum(x * x for x in b_flat) ** 0.5
                if norm_a == 0 or norm_b == 0:
                    return 0.0
                return 1.0 - (dot_product / (norm_a * norm_b))