deepeval 3.4.7__py3-none-any.whl → 3.4.9__py3-none-any.whl

deepeval/models/llms/openai_model.py

@@ -1,26 +1,33 @@
+import logging
+
 from openai.types.chat.chat_completion import ChatCompletion
 from deepeval.key_handler import ModelKeyValues, KEY_FILE_HANDLER
 from typing import Optional, Tuple, Union, Dict
-from openai import OpenAI, AsyncOpenAI
 from pydantic import BaseModel
-import logging
-import openai
 
-from tenacity import (
-    retry,
-    retry_if_exception_type,
-    wait_exponential_jitter,
-    RetryCallState,
+from openai import (
+    OpenAI,
+    AsyncOpenAI,
 )
 
+from tenacity import retry, RetryCallState, before_sleep_log
+
 from deepeval.models import DeepEvalBaseLLM
 from deepeval.models.llms.utils import trim_and_load_json
 from deepeval.models.utils import parse_model_name
+from deepeval.models.retry_policy import (
+    OPENAI_ERROR_POLICY,
+    default_wait,
+    default_stop,
+    retry_predicate,
+)
+
+logger = logging.getLogger("deepeval.openai_model")
 
 
 def log_retry_error(retry_state: RetryCallState):
     exception = retry_state.outcome.exception()
-    logging.error(
+    logger.error(
         f"OpenAI Error: {exception} Retrying: {retry_state.attempt_number} time(s)..."
     )
 
@@ -212,14 +219,22 @@ models_requiring_temperature_1 = [
     "gpt-5-chat-latest",
 ]
 
-retryable_exceptions = (
-    openai.RateLimitError,
-    openai.APIConnectionError,
-    openai.APITimeoutError,
-    openai.LengthFinishReasonError,
+_base_retry_rules_kw = dict(
+    wait=default_wait(),
+    stop=default_stop(),
+    retry=retry_predicate(OPENAI_ERROR_POLICY),
+    before_sleep=before_sleep_log(
+        logger, logging.INFO
+    ),  # <- logs only on retries
+    after=log_retry_error,
 )
 
 
+def _openai_client_kwargs():
+    # Avoid double-retry at SDK layer by disabling the SDK's own retries so tenacity is the single source of truth for retry logic.
+    return {"max_retries": 0}
+
+
 class GPTModel(DeepEvalBaseLLM):
     def __init__(
         self,
@@ -296,11 +311,7 @@ class GPTModel(DeepEvalBaseLLM):
     # Generate functions
     ###############################################
 
-    @retry(
-        wait=wait_exponential_jitter(initial=1, exp_base=2, jitter=2, max=10),
-        retry=retry_if_exception_type(retryable_exceptions),
-        after=log_retry_error,
-    )
+    @retry(**_base_retry_rules_kw)
     def generate(
         self, prompt: str, schema: Optional[BaseModel] = None
     ) -> Tuple[Union[str, Dict], float]:
@@ -359,11 +370,7 @@ class GPTModel(DeepEvalBaseLLM):
         else:
             return output, cost
 
-    @retry(
-        wait=wait_exponential_jitter(initial=1, exp_base=2, jitter=2, max=10),
-        retry=retry_if_exception_type(retryable_exceptions),
-        after=log_retry_error,
-    )
+    @retry(**_base_retry_rules_kw)
     async def a_generate(
         self, prompt: str, schema: Optional[BaseModel] = None
     ) -> Tuple[Union[str, BaseModel], float]:
@@ -427,11 +434,7 @@ class GPTModel(DeepEvalBaseLLM):
     # Other generate functions
     ###############################################
 
-    @retry(
-        wait=wait_exponential_jitter(initial=1, exp_base=2, jitter=2, max=10),
-        retry=retry_if_exception_type(retryable_exceptions),
-        after=log_retry_error,
-    )
+    @retry(**_base_retry_rules_kw)
     def generate_raw_response(
         self,
         prompt: str,
@@ -454,11 +457,7 @@ class GPTModel(DeepEvalBaseLLM):
 
         return completion, cost
 
-    @retry(
-        wait=wait_exponential_jitter(initial=1, exp_base=2, jitter=2, max=10),
-        retry=retry_if_exception_type(retryable_exceptions),
-        after=log_retry_error,
-    )
+    @retry(**_base_retry_rules_kw)
     async def a_generate_raw_response(
         self,
         prompt: str,
@@ -481,11 +480,7 @@ class GPTModel(DeepEvalBaseLLM):
 
         return completion, cost
 
-    @retry(
-        wait=wait_exponential_jitter(initial=1, exp_base=2, jitter=2, max=10),
-        retry=retry_if_exception_type(retryable_exceptions),
-        after=log_retry_error,
-    )
+    @retry(**_base_retry_rules_kw)
     def generate_samples(
         self, prompt: str, n: int, temperature: float
     ) -> Tuple[list[str], float]:
@@ -518,12 +513,13 @@ class GPTModel(DeepEvalBaseLLM):
         return self.model_name
 
     def load_model(self, async_mode: bool = False):
+        kwargs = {**self.kwargs, **_openai_client_kwargs()}
         if not async_mode:
             return OpenAI(
                 api_key=self._openai_api_key,
                 base_url=self.base_url,
-                **self.kwargs,
+                **kwargs,
             )
         return AsyncOpenAI(
-            api_key=self._openai_api_key, base_url=self.base_url, **self.kwargs
+            api_key=self._openai_api_key, base_url=self.base_url, **kwargs
         )

deepeval/models/retry_policy.py

@@ -0,0 +1,280 @@
+"""Generic retry policy helpers for provider SDKs.
+
+This module lets models define *what is transient* vs *non-retryable* (permanent) failure
+without coupling to a specific SDK. You provide an `ErrorPolicy` describing
+exception classes and special “non-retryable” error codes, such as quota-exhausted from OpenAI,
+and get back a Tenacity predicate suitable for `retry_if_exception`.
+
+Typical use:
+
+    # Import dependencies
+    from tenacity import retry, before_sleep_log
+    from deepeval.models.retry_policy import (
+        OPENAI_ERROR_POLICY, default_wait, default_stop, retry_predicate
+    )
+
+    # Define retry rule keywords
+    _retry_kw = dict(
+        wait=default_wait(),
+        stop=default_stop(),
+        retry=retry_predicate(OPENAI_ERROR_POLICY),
+        before_sleep=before_sleep_log(logger, logging.INFO), # <- Optional: logs only on retries
+    )
+
+    # Apply retry rule keywords where desired
+    @retry(**_retry_kw)
+    def call_openai(...):
+        ...
+"""
+
+from __future__ import annotations
+
+import logging
+
+from deepeval.utils import read_env_int, read_env_float
+from dataclasses import dataclass, field
+from typing import Iterable, Mapping, Callable, Sequence, Tuple
+from collections.abc import Mapping as ABCMapping
+from tenacity import (
+    wait_exponential_jitter,
+    stop_after_attempt,
+    retry_if_exception,
+)
+
+
+logger = logging.getLogger(__name__)
+
+# --------------------------
+# Policy description
+# --------------------------
+
+
+@dataclass(frozen=True)
+class ErrorPolicy:
+    """Describe exception classes & rules for retry classification.
+
+    Attributes:
+        auth_excs: Exceptions that indicate authentication/authorization problems.
+                   These are treated as non-retryable.
+        rate_limit_excs: Exceptions representing rate limiting (HTTP 429).
+        network_excs: Exceptions for timeouts / connection issues (transient).
+        http_excs: Exceptions carrying an integer `status_code` (4xx, 5xx)
+        non_retryable_codes: Error “code” strings that should be considered permanent,
+                             such as "insufficient_quota". Used to refine rate-limit handling.
+        retry_5xx: Whether to retry provider 5xx responses (defaults to True).
+    """
+
+    auth_excs: Tuple[type[Exception], ...]
+    rate_limit_excs: Tuple[type[Exception], ...]
+    network_excs: Tuple[type[Exception], ...]
+    http_excs: Tuple[type[Exception], ...]
+    non_retryable_codes: frozenset[str] = field(default_factory=frozenset)
+    retry_5xx: bool = True
+    message_markers: Mapping[str, Iterable[str]] = field(default_factory=dict)
+
+
+# --------------------------
+# Extraction helpers
+# --------------------------
+
+
+def extract_error_code(
+    e: Exception,
+    *,
+    response_attr: str = "response",
+    body_attr: str = "body",
+    code_path: Sequence[str] = ("error", "code"),
+    message_markers: Mapping[str, Iterable[str]] | None = None,
+) -> str:
+    """Best effort extraction of an error 'code' for SDK compatibility.
+
+    Order of attempts:
+      1) Structured JSON via `e.response.json()` (typical HTTP error payload).
+      2) A dict stored on `e.body` (some gateways/proxies use this).
+      3) Message sniffing fallback, using `message_markers`.
+
+    Args:
+        e: The exception raised by the SDK/provider client.
+        response_attr: Attribute name that holds an HTTP response object.
+        body_attr: Attribute name that may hold a parsed payload (dict).
+        code_path: Path of keys to traverse to the code (e.g., ["error", "code"]).
+        message_markers: Mapping from canonical code -> substrings to search for.
+
+    Returns:
+        The code string if found, else "".
+    """
+    # 1) Structured JSON in e.response.json()
+    resp = getattr(e, response_attr, None)
+    if resp is not None:
+        try:
+            cur = resp.json()
+            for k in code_path:
+                if not isinstance(cur, ABCMapping):
+                    cur = {}
+                    break
+                cur = cur.get(k, {})
+            if isinstance(cur, (str, int)):
+                return str(cur)
+        except Exception:
+            # response.json() can raise; ignore and fall through
+            pass
+
+    # 2) SDK provided dict body
+    body = getattr(e, body_attr, None)
+    if isinstance(body, ABCMapping):
+        cur = body
+        for k in code_path:
+            if not isinstance(cur, ABCMapping):
+                cur = {}
+                break
+            cur = cur.get(k, {})
+        if isinstance(cur, (str, int)):
+            return str(cur)
+
+    # 3) Message sniff (hopefully this helps catch message codes that slip past the previous 2 parsers)
+    msg = str(e).lower()
+    markers = message_markers or {}
+    for code_key, needles in markers.items():
+        if any(n in msg for n in needles):
+            return code_key
+
+    return ""
+
+
+# --------------------------
+# Predicate factory
+# --------------------------
+
+
+def make_is_transient(
+    policy: ErrorPolicy,
+    *,
+    message_markers: Mapping[str, Iterable[str]] | None = None,
+    extra_non_retryable_codes: Iterable[str] = (),
+) -> Callable[[Exception], bool]:
+    """Create a Tenacity predicate: True = retry, False = surface immediately.
+
+    Semantics:
+        - Auth errors: non-retryable.
+        - Rate limit errors: retry unless the extracted code is in the non-retryable set
+        - Network/timeout errors: retry.
+        - HTTP errors with a `status_code`: retry 5xx if `policy.retry_5xx` is True.
+        - Everything else: treated as non-retryable.
+
+    Args:
+        policy: An ErrorPolicy describing error classes and rules.
+        message_markers: Optional override/extension for code inference via message text.
+        extra_non_retryable_codes: Additional code strings to treat as non-retryable.
+
+    Returns:
+        A callable `predicate(e) -> bool` suitable for `retry_if_exception`.
+    """
+    non_retryable = frozenset(policy.non_retryable_codes) | frozenset(
+        extra_non_retryable_codes
+    )
+
+    def _pred(e: Exception) -> bool:
+        if isinstance(e, policy.auth_excs):
+            return False
+
+        if isinstance(e, policy.rate_limit_excs):
+            code = extract_error_code(
+                e, message_markers=(message_markers or policy.message_markers)
+            )
+            return code not in non_retryable
+
+        if isinstance(e, policy.network_excs):
+            return True
+
+        if isinstance(e, policy.http_excs):
+            try:
+                sc = int(getattr(e, "status_code", 0))
+            except Exception:
+                sc = 0
+            return policy.retry_5xx and 500 <= sc < 600
+
+        return False
+
+    return _pred
+
+
+# --------------------------
+# Tenacity convenience
+# --------------------------
+
+
+def default_wait():
+    """Default backoff: exponential with jitter, capped.
+    Overridable via env:
+      - DEEPEVAL_RETRY_INITIAL_SECONDS (>=0)
+      - DEEPEVAL_RETRY_EXP_BASE      (>=1)
+      - DEEPEVAL_RETRY_JITTER        (>=0)
+      - DEEPEVAL_RETRY_CAP_SECONDS   (>=0)
+    """
+    initial = read_env_float(
+        "DEEPEVAL_RETRY_INITIAL_SECONDS", 1.0, min_value=0.0
+    )
+    exp_base = read_env_float("DEEPEVAL_RETRY_EXP_BASE", 2.0, min_value=1.0)
+    jitter = read_env_float("DEEPEVAL_RETRY_JITTER", 2.0, min_value=0.0)
+    cap = read_env_float("DEEPEVAL_RETRY_CAP_SECONDS", 5.0, min_value=0.0)
+    return wait_exponential_jitter(
+        initial=initial, exp_base=exp_base, jitter=jitter, max=cap
+    )
+
+
+def default_stop():
+    """Default stop condition: at most N attempts (N-1 retries).
+    Overridable via env:
+      - DEEPEVAL_RETRY_MAX_ATTEMPTS (>=1)
+    """
+    attempts = read_env_int("DEEPEVAL_RETRY_MAX_ATTEMPTS", 2, min_value=1)
+    return stop_after_attempt(attempts)
+
+
+def retry_predicate(policy: ErrorPolicy, **kw):
+    """Build a Tenacity `retry=` argument from a policy.
+
+    Example:
+        retry=retry_predicate(OPENAI_ERROR_POLICY, extra_non_retryable_codes=["some_code"])
+    """
+    return retry_if_exception(make_is_transient(policy, **kw))
+
+
+# --------------------------
+# Built-in policies
+# --------------------------
+OPENAI_MESSAGE_MARKERS: dict[str, tuple[str, ...]] = {
+    "insufficient_quota": ("insufficient_quota", "exceeded your current quota"),
+}
+
+try:
+    from openai import (
+        AuthenticationError,
+        RateLimitError,
+        APIConnectionError,
+        APITimeoutError,
+        APIStatusError,
+    )
+
+    OPENAI_ERROR_POLICY = ErrorPolicy(
+        auth_excs=(AuthenticationError,),
+        rate_limit_excs=(RateLimitError,),
+        network_excs=(APIConnectionError, APITimeoutError),
+        http_excs=(APIStatusError,),
+        non_retryable_codes=frozenset({"insufficient_quota"}),
+        message_markers=OPENAI_MESSAGE_MARKERS,
+    )
+except Exception:  # pragma: no cover - OpenAI may not be installed in some envs
+    OPENAI_ERROR_POLICY = None
+
+
+__all__ = [
+    "ErrorPolicy",
+    "extract_error_code",
+    "make_is_transient",
+    "default_wait",
+    "default_stop",
+    "retry_predicate",
+    "OPENAI_MESSAGE_MARKERS",
+    "OPENAI_ERROR_POLICY",
+]

deepeval/openai_agents/agent.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field, replace
-from typing import Any, Optional, Awaitable, Callable
+from typing import Any, Optional, Awaitable, Callable, Generic, TypeVar
 
 from deepeval.tracing import observe
 from deepeval.prompt import Prompt
@@ -14,6 +14,8 @@ except Exception as e:
         "openai-agents is required for this integration. Please install it."
     ) from e
 
+TContext = TypeVar("TContext")
+
 
 class _ObservedModel(Model):
     def __init__(
@@ -153,7 +155,7 @@ class _ObservedProvider(ModelProvider):
 
 
 @dataclass
-class DeepEvalAgent(BaseAgent[Any]):
+class DeepEvalAgent(BaseAgent[TContext], Generic[TContext]):
     """
     A subclass of agents.Agent that accepts `metrics` and `metric_collection`
     and ensures the underlying model's `get_response` is wrapped with deepeval.observe.

deepeval/synthesizer/chunking/doc_chunker.py

@@ -1,47 +1,72 @@
-from typing import Optional, List, Dict, Union, Type
 import os
 
+from typing import Dict, List, Optional, Type, TYPE_CHECKING
+from types import SimpleNamespace
+
 from deepeval.models.base_model import DeepEvalBaseEmbeddingModel
 
-# check langchain availability
-try:
+
+if TYPE_CHECKING:
+    from chromadb.api.models.Collection import Collection
     from langchain_core.documents import Document as LCDocument
-    from langchain_text_splitters import TokenTextSplitter
     from langchain_text_splitters.base import TextSplitter
-    from langchain_community.document_loaders import (
-        PyPDFLoader,
-        TextLoader,
-        Docx2txtLoader,
-    )
     from langchain_community.document_loaders.base import BaseLoader
 
-    langchain_available = True
-except ImportError:
-    langchain_available = False
-
-# check chromadb availability
-try:
-    import chromadb
-    from chromadb import Metadata
-    from chromadb.api.models.Collection import Collection
-
-    chroma_db_available = True
-except ImportError:
-    chroma_db_available = False
 
-
-# Define a helper function to check availability
-def _check_chromadb_available():
-    if not chroma_db_available:
+# Lazy import caches
+_langchain_ns = None
+_chroma_mod = None
+_langchain_import_error = None
+_chroma_import_error = None
+
+
+def _get_langchain():
+    """Return a namespace of langchain classes, or raise ImportError with root cause."""
+    global _langchain_ns, _langchain_import_error
+    if _langchain_ns is not None:
+        return _langchain_ns
+    try:
+        from langchain_core.documents import Document as LCDocument  # type: ignore
+        from langchain_text_splitters import TokenTextSplitter  # type: ignore
+        from langchain_text_splitters.base import TextSplitter  # type: ignore
+        from langchain_community.document_loaders import (  # type: ignore
+            PyPDFLoader,
+            TextLoader,
+            Docx2txtLoader,
+        )
+        from langchain_community.document_loaders.base import BaseLoader  # type: ignore
+
+        _langchain_ns = SimpleNamespace(
+            LCDocument=LCDocument,
+            TokenTextSplitter=TokenTextSplitter,
+            TextSplitter=TextSplitter,
+            PyPDFLoader=PyPDFLoader,
+            TextLoader=TextLoader,
+            Docx2txtLoader=Docx2txtLoader,
+            BaseLoader=BaseLoader,
+        )
+        return _langchain_ns
+    except Exception as e:
+        _langchain_import_error = e
         raise ImportError(
-            "chromadb is required for this functionality. Install it via your package manager"
+            f"langchain, langchain_community, and langchain_text_splitters are required. Root cause: {e}"
         )
 
 
-def _check_langchain_available():
-    if not langchain_available:
+def _get_chromadb():
+    """Return the chromadb module, or raise ImportError with root cause."""
+    global _chroma_mod, _chroma_import_error
+    if _chroma_mod is not None:
+        return _chroma_mod
+    try:
+        import chromadb
+
+        _chroma_mod = chromadb
+        return _chroma_mod
+    except Exception as e:
+        _chroma_import_error = e
         raise ImportError(
-            "langchain, langchain_community, and langchain_text_splitters are required for this functionality. Install it via your package manager"
+            f"chromadb is required for this functionality. Root cause: {e}"
         )
 
 
@@ -50,22 +75,16 @@ class DocumentChunker:
         self,
         embedder: DeepEvalBaseEmbeddingModel,
     ):
-        _check_chromadb_available()
-        _check_langchain_available()
         self.text_token_count: Optional[int] = None  # set later
 
         self.source_file: Optional[str] = None
         self.chunks: Optional["Collection"] = None
-        self.sections: Optional[List[LCDocument]] = None
+        self.sections: Optional[List["LCDocument"]] = None
         self.embedder: DeepEvalBaseEmbeddingModel = embedder
         self.mean_embedding: Optional[float] = None
 
         # Mapping of file extensions to their respective loader classes
-        self.loader_mapping: Dict[str, Type[BaseLoader]] = {
-            ".pdf": PyPDFLoader,
-            ".txt": TextLoader,
-            ".docx": Docx2txtLoader,
-        }
+        self.loader_mapping: Dict[str, "Type[BaseLoader]"] = {}
 
     #########################################################
     ### Chunking Docs #######################################
@@ -74,7 +93,8 @@ class DocumentChunker:
     async def a_chunk_doc(
         self, chunk_size: int = 1024, chunk_overlap: int = 0
     ) -> "Collection":
-        _check_chromadb_available()
+        lc = _get_langchain()
+        chroma = _get_chromadb()
 
         # Raise error if chunk_doc is called before load_doc
         if self.sections is None or self.source_file is None:
@@ -85,13 +105,13 @@ class DocumentChunker:
         # Create ChromaDB client
         full_document_path, _ = os.path.splitext(self.source_file)
         document_name = os.path.basename(full_document_path)
-        client = chromadb.PersistentClient(path=f".vector_db/{document_name}")
+        client = chroma.PersistentClient(path=f".vector_db/{document_name}")
 
         collection_name = f"processed_chunks_{chunk_size}_{chunk_overlap}"
         try:
             collection = client.get_collection(name=collection_name)
         except Exception:
-            text_splitter: TextSplitter = TokenTextSplitter(
+            text_splitter: "TextSplitter" = lc.TokenTextSplitter(
                 chunk_size=chunk_size, chunk_overlap=chunk_overlap
             )
             # Collection doesn't exist, so create it and then add documents
@@ -108,7 +128,7 @@ class DocumentChunker:
                 batch_contents = contents[i:batch_end]
                 batch_embeddings = embeddings[i:batch_end]
                 batch_ids = ids[i:batch_end]
-                batch_metadatas: List["Metadata"] = [
+                batch_metadatas: List[dict] = [
                     {"source_file": self.source_file} for _ in batch_contents
                 ]
 
@@ -121,7 +141,8 @@ class DocumentChunker:
         return collection
 
     def chunk_doc(self, chunk_size: int = 1024, chunk_overlap: int = 0):
-        _check_chromadb_available()
+        lc = _get_langchain()
+        chroma = _get_chromadb()
 
         # Raise error if chunk_doc is called before load_doc
         if self.sections is None or self.source_file is None:
@@ -132,13 +153,13 @@ class DocumentChunker:
         # Create ChromaDB client
         full_document_path, _ = os.path.splitext(self.source_file)
         document_name = os.path.basename(full_document_path)
-        client = chromadb.PersistentClient(path=f".vector_db/{document_name}")
+        client = chroma.PersistentClient(path=f".vector_db/{document_name}")
 
         collection_name = f"processed_chunks_{chunk_size}_{chunk_overlap}"
         try:
             collection = client.get_collection(name=collection_name)
         except Exception:
-            text_splitter: TextSplitter = TokenTextSplitter(
+            text_splitter: "TextSplitter" = lc.TokenTextSplitter(
                 chunk_size=chunk_size, chunk_overlap=chunk_overlap
             )
             # Collection doesn't exist, so create it and then add documents
@@ -155,7 +176,7 @@ class DocumentChunker:
                 batch_contents = contents[i:batch_end]
                 batch_embeddings = embeddings[i:batch_end]
                 batch_ids = ids[i:batch_end]
-                batch_metadatas: List["Metadata"] = [
+                batch_metadatas: List[dict] = [
                     {"source_file": self.source_file} for _ in batch_contents
                 ]
 
@@ -172,17 +193,31 @@ class DocumentChunker:
     #########################################################
 
     def get_loader(self, path: str, encoding: Optional[str]) -> "BaseLoader":
+        lc = _get_langchain()
+        # set mapping lazily now that langchain classes exist
+        if not self.loader_mapping:
+            self.loader_mapping = {
+                ".pdf": lc.PyPDFLoader,
+                ".txt": lc.TextLoader,
+                ".docx": lc.Docx2txtLoader,
+                ".md": lc.TextLoader,
+                ".markdown": lc.TextLoader,
+                ".mdx": lc.TextLoader,
+            }
+
         # Find appropriate doc loader
         _, extension = os.path.splitext(path)
         extension = extension.lower()
-        loader: Optional[type[BaseLoader]] = self.loader_mapping.get(extension)
+        loader: Optional["Type[BaseLoader]"] = self.loader_mapping.get(
+            extension
+        )
         if loader is None:
             raise ValueError(f"Unsupported file format: {extension}")
 
-        # Load doc into sections and calculate total character count
-        if loader is TextLoader:
+        # Load doc into sections and calculate total token count
+        if loader is lc.TextLoader:
             return loader(path, encoding=encoding, autodetect_encoding=True)
-        elif loader is PyPDFLoader or loader is Docx2txtLoader:
+        elif loader in (lc.PyPDFLoader, lc.Docx2txtLoader):
             return loader(path)
         else:
             raise ValueError(f"Unsupported file format: {extension}")
@@ -200,5 +235,6 @@ class DocumentChunker:
         self.source_file = path
 
     def count_tokens(self, chunks: List["LCDocument"]):
-        counter = TokenTextSplitter(chunk_size=1, chunk_overlap=0)
+        lc = _get_langchain()
+        counter = lc.TokenTextSplitter(chunk_size=1, chunk_overlap=0)
         return len(counter.split_documents(chunks))