lfx-nightly 0.2.0.dev26__py3-none-any.whl → 0.2.1.dev7__py3-none-any.whl

lfx/base/models/watsonx_constants.py

@@ -1,29 +1,65 @@
 from .model_metadata import create_model_metadata
 
+WATSONX_DEFAULT_LLM_MODELS = [
+    create_model_metadata(
+        provider="IBM Watsonx",
+        name="ibm/granite-3-2b-instruct",
+        icon="WatsonxAI",
+        model_type="llm",
+        default=True,
+    ),
+    create_model_metadata(
+        provider="IBM Watsonx",
+        name="ibm/granite-3-8b-instruct",
+        icon="WatsonxAI",
+        model_type="llm",
+        default=True,
+    ),
+    create_model_metadata(
+        provider="IBM Watsonx",
+        name="ibm/granite-13b-instruct-v2",
+        icon="WatsonxAI",
+        model_type="llm",
+        default=True,
+    ),
+]
+
 WATSONX_DEFAULT_EMBEDDING_MODELS = [
     create_model_metadata(
         provider="IBM Watsonx",
         name="sentence-transformers/all-minilm-l12-v2",
         icon="WatsonxAI",
+        model_type="embeddings",
+        default=True,
     ),
     create_model_metadata(
         provider="IBM Watsonx",
         name="ibm/slate-125m-english-rtrvr-v2",
         icon="WatsonxAI",
+        model_type="embeddings",
+        default=True,
     ),
     create_model_metadata(
         provider="IBM Watsonx",
         name="ibm/slate-30m-english-rtrvr-v2",
         icon="WatsonxAI",
+        model_type="embeddings",
+        default=True,
     ),
     create_model_metadata(
         provider="IBM Watsonx",
         name="intfloat/multilingual-e5-large",
         icon="WatsonxAI",
+        model_type="embeddings",
+        default=True,
     ),
 ]
 
 
+WATSONX_EMBEDDING_MODELS_DETAILED = WATSONX_DEFAULT_EMBEDDING_MODELS
+# Combined list for all watsonx models
+WATSONX_MODELS_DETAILED = WATSONX_DEFAULT_LLM_MODELS + WATSONX_DEFAULT_EMBEDDING_MODELS
+
 WATSONX_EMBEDDING_MODEL_NAMES = [metadata["name"] for metadata in WATSONX_DEFAULT_EMBEDDING_MODELS]
 
 IBM_WATSONX_URLS = [

lfx/base/tools/component_tool.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import re
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING
 
 import pandas as pd
 from langchain_core.tools import BaseTool, ToolException
@@ -22,7 +22,6 @@ if TYPE_CHECKING:
     from lfx.events.event_manager import EventManager
     from lfx.inputs.inputs import InputTypes
     from lfx.io import Output
-    from lfx.schema.content_block import ContentBlock
     from lfx.schema.dotdict import dotdict
 
 TOOL_TYPES_SET = {"Tool", "BaseTool", "StructuredTool"}
@@ -42,15 +41,9 @@ def build_description(component: Component) -> str:
 
 async def send_message_noop(
     message: Message,
-    text: str | None = None,  # noqa: ARG001
-    background_color: str | None = None,  # noqa: ARG001
-    text_color: str | None = None,  # noqa: ARG001
-    icon: str | None = None,  # noqa: ARG001
-    content_blocks: list[ContentBlock] | None = None,  # noqa: ARG001
-    format_type: Literal["default", "error", "warning", "info"] = "default",  # noqa: ARG001
     id_: str | None = None,  # noqa: ARG001
     *,
-    allow_markdown: bool = True,  # noqa: ARG001
+    skip_db_update: bool = False,  # noqa: ARG001
 ) -> Message:
     """No-op implementation of send_message."""
     return message

lfx/cli/commands.py

@@ -303,13 +303,18 @@ async def serve_command(
         console.print()
 
         # Start the server
+        # Use uvicorn.Server to properly handle async context
+        # uvicorn.run() uses asyncio.run() internally which fails when
+        # an event loop is already running (due to syncify decorator)
         try:
-            uvicorn.run(
+            config = uvicorn.Config(
                 serve_app,
                 host=host,
                 port=port,
                 log_level=log_level,
             )
+            server = uvicorn.Server(config)
+            await server.serve()
         except KeyboardInterrupt:
             verbose_print("\n👋 Server stopped")
             raise typer.Exit(0) from None

lfx/cli/run.py

@@ -1,47 +1,50 @@
+"""CLI wrapper for the run command."""
+
 import json
-import re
-import sys
-import tempfile
 from functools import partial
-from io import StringIO
 from pathlib import Path
 
 import typer
 from asyncer import syncify
 
-from lfx.cli.script_loader import (
-    extract_structured_result,
-    extract_text_from_result,
-    find_graph_variable,
-    load_graph_from_script,
-)
-from lfx.cli.validation import validate_global_variables_for_env
-from lfx.log.logger import logger
-from lfx.schema.schema import InputValueRequest
+from lfx.run.base import RunError, run_flow
 
 # Verbosity level constants
 VERBOSITY_DETAILED = 2
 VERBOSITY_FULL = 3
 
 
-def output_error(error_message: str, *, verbose: bool, exception: Exception | None = None) -> None:
-    """Output error in JSON format to stdout when not verbose, or to stderr when verbose."""
-    if verbose:
-        typer.echo(f"{error_message}", file=sys.stderr)
-
-    error_response = {
-        "success": False,
-        "type": "error",
-    }
+def _check_langchain_version_compatibility(error_message: str) -> str | None:
+    """Check if error is due to langchain-core version incompatibility.
 
-    # Add clean exception data if available
-    if exception:
-        error_response["exception_type"] = type(exception).__name__
-        error_response["exception_message"] = str(exception)
-    else:
-        error_response["exception_message"] = error_message
-
-    typer.echo(json.dumps(error_response))
+    Returns a helpful error message if incompatibility is detected, None otherwise.
+    """
+    # Check for the specific error that occurs with langchain-core 1.x
+    # The langchain_core.memory module was removed in langchain-core 1.x
+    if "langchain_core.memory" in error_message or "No module named 'langchain_core.memory'" in error_message:
+        try:
+            import langchain_core
+
+            version = getattr(langchain_core, "__version__", "unknown")
+        except ImportError:
+            version = "unknown"
+
+        return (
+            f"ERROR: Incompatible langchain-core version (v{version}).\n\n"
+            "The 'langchain_core.memory' module was removed in langchain-core 1.x.\n"
+            "lfx requires langchain-core < 1.0.0.\n\n"
+            "This usually happens when langchain-openai >= 1.0.0 is installed,\n"
+            "which pulls in langchain-core >= 1.0.0.\n\n"
+            "FIX: Reinstall with compatible versions:\n\n"
+            "  uv pip install 'langchain-core>=0.3.0,<1.0.0' \\\n"
+            "                 'langchain-openai>=0.3.0,<1.0.0' \\\n"
+            "                 'langchain-community>=0.3.0,<1.0.0'\n\n"
+            "Or with pip:\n\n"
+            "  pip install 'langchain-core>=0.3.0,<1.0.0' \\\n"
+            "              'langchain-openai>=0.3.0,<1.0.0' \\\n"
+            "              'langchain-community>=0.3.0,<1.0.0'"
+        )
+    return None
 
 
 @partial(syncify, raise_sync_error=False)
@@ -119,388 +122,41 @@ async def run(
         check_variables: Check global variables for environment compatibility
         timing: Include detailed timing information in output
     """
-    # Start timing if requested
-    import time
-
-    # Configure logger based on verbosity level
-    from lfx.log.logger import configure
-
-    if verbose_full:
-        configure(log_level="DEBUG", output_file=sys.stderr)  # Show everything including component debug logs
-        verbosity = 3
-    elif verbose_detailed:
-        configure(log_level="DEBUG", output_file=sys.stderr)  # Show debug and above
-        verbosity = 2
-    elif verbose:
-        configure(log_level="INFO", output_file=sys.stderr)  # Show info and above including our CLI info messages
-        verbosity = 1
-    else:
-        configure(log_level="CRITICAL", output_file=sys.stderr)  # Only critical errors
-        verbosity = 0
-
-    start_time = time.time() if timing else None
-
-    # Use either positional input_value or --input-value option
-    final_input_value = input_value or input_value_option
-
-    # Validate input sources - exactly one must be provided
-    input_sources = [script_path is not None, flow_json is not None, bool(stdin)]
-    if sum(input_sources) != 1:
-        if sum(input_sources) == 0:
-            error_msg = "No input source provided. Must provide either script_path, --flow-json, or --stdin"
-        else:
-            error_msg = (
-                "Multiple input sources provided. Cannot use script_path, --flow-json, and "
-                "--stdin together. Choose exactly one."
-            )
-        output_error(error_msg, verbose=verbose)
-        raise typer.Exit(1)
-
-    temp_file_to_cleanup = None
-
-    if flow_json is not None:
-        if verbosity > 0:
-            typer.echo("Processing inline JSON content...", file=sys.stderr)
-        try:
-            json_data = json.loads(flow_json)
-            if verbosity > 0:
-                typer.echo("JSON content is valid", file=sys.stderr)
-            with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as temp_file:
-                json.dump(json_data, temp_file, indent=2)
-                temp_file_to_cleanup = temp_file.name
-            script_path = Path(temp_file_to_cleanup)
-            if verbosity > 0:
-                typer.echo(f"Created temporary file: {script_path}", file=sys.stderr)
-        except json.JSONDecodeError as e:
-            output_error(f"Invalid JSON content: {e}", verbose=verbose)
-            raise typer.Exit(1) from e
-        except Exception as e:
-            output_error(f"Error processing JSON content: {e}", verbose=verbose)
-            raise typer.Exit(1) from e
-    elif stdin:
-        if verbosity > 0:
-            typer.echo("Reading JSON content from stdin...", file=sys.stderr)
-        try:
-            stdin_content = sys.stdin.read().strip()
-            if not stdin_content:
-                output_error("No content received from stdin", verbose=verbose)
-                raise typer.Exit(1)
-            json_data = json.loads(stdin_content)
-            if verbosity > 0:
-                typer.echo("JSON content from stdin is valid", file=sys.stderr)
-            with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as temp_file:
-                json.dump(json_data, temp_file, indent=2)
-                temp_file_to_cleanup = temp_file.name
-            script_path = Path(temp_file_to_cleanup)
-            if verbosity > 0:
-                typer.echo(f"Created temporary file from stdin: {script_path}", file=sys.stderr)
-        except json.JSONDecodeError as e:
-            output_error(f"Invalid JSON content from stdin: {e}", verbose=verbose)
-            raise typer.Exit(1) from e
-        except Exception as e:
-            output_error(f"Error reading from stdin: {e}", verbose=verbose)
-            raise typer.Exit(1) from e
-
-    try:
-        if not script_path or not script_path.exists():
-            error_msg = f"File '{script_path}' does not exist."
-            raise ValueError(error_msg)
-        if not script_path.is_file():
-            error_msg = f"'{script_path}' is not a file."
-            raise ValueError(error_msg)
-        file_extension = script_path.suffix.lower()
-        if file_extension not in [".py", ".json"]:
-            error_msg = f"'{script_path}' must be a .py or .json file."
-            raise ValueError(error_msg)
-        file_type = "Python script" if file_extension == ".py" else "JSON flow"
-        if verbosity > 0:
-            typer.echo(f"Analyzing {file_type}: {script_path}", file=sys.stderr)
-        if file_extension == ".py":
-            graph_info = find_graph_variable(script_path)
-            if not graph_info:
-                error_msg = (
-                    "No 'graph' variable found in the script. Expected to find an assignment like: graph = Graph(...)"
-                )
-                raise ValueError(error_msg)
-            if verbosity > 0:
-                typer.echo(f"Found 'graph' variable at line {graph_info['line_number']}", file=sys.stderr)
-                typer.echo(f"Type: {graph_info['type']}", file=sys.stderr)
-                typer.echo(f"Source: {graph_info['source_line']}", file=sys.stderr)
-                typer.echo("Loading and executing script...", file=sys.stderr)
-            graph = await load_graph_from_script(script_path)
-        elif file_extension == ".json":
-            if verbosity > 0:
-                typer.echo("Valid JSON flow file detected", file=sys.stderr)
-                typer.echo("Loading and executing JSON flow", file=sys.stderr)
-            from lfx.load import aload_flow_from_json
-
-            graph = await aload_flow_from_json(script_path, disable_logs=not verbose)
-    except Exception as e:
-        error_type = type(e).__name__
-        logger.error(f"Graph loading failed with {error_type}")
-
-        if verbosity > 0:
-            # Try to identify common error patterns
-            if "ModuleNotFoundError" in str(e) or "No module named" in str(e):
-                logger.info("This appears to be a missing dependency issue")
-                if "langchain" in str(e).lower():
-                    match = re.search(r"langchain_(.*)", str(e).lower())
-                    if match:
-                        module_name = match.group(1)
-                        logger.info(
-                            f"Missing LangChain dependency detected. Try: pip install langchain-{module_name}",
-                        )
-            elif "ImportError" in str(e):
-                logger.info("This appears to be an import issue - check component dependencies")
-            elif "AttributeError" in str(e):
-                logger.info("This appears to be a component configuration issue")
-
-            # Show full traceback in debug mode
-            logger.exception("Failed to load graph.")
-
-        output_error(f"Failed to load graph. {e}", verbose=verbose, exception=e)
-        if temp_file_to_cleanup:
-            try:
-                Path(temp_file_to_cleanup).unlink()
-                logger.info(f"Cleaned up temporary file: {temp_file_to_cleanup}")
-            except OSError:
-                pass
-        raise typer.Exit(1) from e
-
-    inputs = InputValueRequest(input_value=final_input_value) if final_input_value else None
+    # Determine verbosity for output formatting
+    verbosity = 3 if verbose_full else (2 if verbose_detailed else (1 if verbose else 0))
 
-    # Mark end of loading phase if timing
-    load_end_time = time.time() if timing else None
-
-    if verbosity > 0:
-        typer.echo("Preparing graph for execution...", file=sys.stderr)
     try:
-        # Add detailed preparation steps
-        if verbosity > 0:
-            logger.debug(f"Graph contains {len(graph.vertices)} vertices")
-            logger.debug(f"Graph contains {len(graph.edges)} edges")
-
-            # Show component types being used
-            component_types = set()
-            for vertex in graph.vertices:
-                if hasattr(vertex, "display_name"):
-                    component_types.add(vertex.display_name)
-            logger.debug(f"Component types in graph: {', '.join(sorted(component_types))}")
-
-        graph.prepare()
-        logger.info("Graph preparation completed")
-
-        # Validate global variables for environment compatibility
-        if check_variables:
-            logger.info("Validating global variables...")
-            validation_errors = validate_global_variables_for_env(graph)
-            if validation_errors:
-                error_details = "Global variable validation failed: " + "; ".join(validation_errors)
-                logger.info(f"Variable validation failed: {len(validation_errors)} errors")
-                for error in validation_errors:
-                    logger.debug(f"Validation error: {error}")
-                output_error(error_details, verbose=verbose)
-            if temp_file_to_cleanup:
-                try:
-                    Path(temp_file_to_cleanup).unlink()
-                    logger.info(f"Cleaned up temporary file: {temp_file_to_cleanup}")
-                except OSError:
-                    pass
-            if validation_errors:
-                raise typer.Exit(1)
-            logger.info("Global variable validation passed")
+        result = await run_flow(
+            script_path=script_path,
+            input_value=input_value,
+            input_value_option=input_value_option,
+            output_format=output_format,
+            flow_json=flow_json,
+            stdin=bool(stdin),
+            check_variables=check_variables,
+            verbose=verbose,
+            verbose_detailed=verbose_detailed,
+            verbose_full=verbose_full,
+            timing=timing,
+            global_variables=None,
+        )
+
+        # Output based on format
+        if output_format in {"text", "message", "result"}:
+            typer.echo(result.get("output", ""))
         else:
-            logger.info("Global variable validation skipped")
-    except Exception as e:
-        error_type = type(e).__name__
-        logger.info(f"Graph preparation failed with {error_type}")
-
-        if verbosity > 0:
-            logger.debug(f"Preparation error: {e!s}")
-            logger.exception("Failed to prepare graph - full traceback:")
+            indent = 2 if verbosity > 0 else None
+            typer.echo(json.dumps(result, indent=indent))
 
-        output_error(f"Failed to prepare graph: {e}", verbose=verbose, exception=e)
-        if temp_file_to_cleanup:
-            try:
-                Path(temp_file_to_cleanup).unlink()
-                logger.info(f"Cleaned up temporary file: {temp_file_to_cleanup}")
-            except OSError:
-                pass
-        raise typer.Exit(1) from e
-
-    logger.info("Executing graph...")
-    execution_start_time = time.time() if timing else None
-    if verbose:
-        logger.debug("Setting up execution environment")
-        if inputs:
-            logger.debug(f"Input provided: {inputs.input_value}")
+    except RunError as e:
+        error_response = {
+            "success": False,
+            "type": "error",
+        }
+        if e.original_exception:
+            error_response["exception_type"] = type(e.original_exception).__name__
+            error_response["exception_message"] = str(e.original_exception)
         else:
-            logger.debug("No input provided")
-
-    captured_stdout = StringIO()
-    captured_stderr = StringIO()
-    original_stdout = sys.stdout
-    original_stderr = sys.stderr
-
-    # Track component timing if requested
-    component_timings = [] if timing else None
-    execution_step_start = execution_start_time if timing else None
-
-    try:
-        sys.stdout = captured_stdout
-        # Don't capture stderr at high verbosity levels to avoid duplication with direct logging
-        if verbosity < VERBOSITY_FULL:
-            sys.stderr = captured_stderr
-        results = []
-
-        logger.info("Starting graph execution...", level="DEBUG")
-        result_count = 0
-
-        async for result in graph.async_start(inputs):
-            result_count += 1
-            if verbosity > 0:
-                logger.debug(f"Processing result #{result_count}")
-                if hasattr(result, "vertex") and hasattr(result.vertex, "display_name"):
-                    logger.debug(f"Component: {result.vertex.display_name}")
-            if timing:
-                step_end_time = time.time()
-                step_duration = step_end_time - execution_step_start
-
-                # Extract component information
-                if hasattr(result, "vertex"):
-                    component_name = getattr(result.vertex, "display_name", "Unknown")
-                    component_id = getattr(result.vertex, "id", "Unknown")
-                    component_timings.append(
-                        {
-                            "component": component_name,
-                            "component_id": component_id,
-                            "duration": step_duration,
-                            "cumulative_time": step_end_time - execution_start_time,
-                        }
-                    )
-
-                execution_step_start = step_end_time
-
-            results.append(result)
-
-        logger.info(f"Graph execution completed. Processed {result_count} results")
-
-    except Exception as e:
-        error_type = type(e).__name__
-        logger.info(f"Graph execution failed with {error_type}")
-
-        if verbosity >= VERBOSITY_DETAILED:  # Only show details at -vv and above
-            logger.debug(f"Failed after processing {result_count} results")
-
-        # Only show component output at maximum verbosity (-vvv)
-        if verbosity >= VERBOSITY_FULL:
-            # Capture any output that was generated before the error
-            # Only show captured stdout since stderr logging is already shown directly in verbose mode
-            captured_content = captured_stdout.getvalue()
-            if captured_content.strip():
-                # Check if captured content contains the same error that will be displayed at the end
-                error_text = str(e)
-                captured_lines = captured_content.strip().split("\n")
-
-                # Filter out lines that are duplicates of the final error message
-                unique_lines = [
-                    line
-                    for line in captured_lines
-                    if not any(
-                        error_part.strip() in line for error_part in error_text.split("\n") if error_part.strip()
-                    )
-                ]
-
-                if unique_lines:
-                    logger.info("Component output before error:", level="DEBUG")
-                    for line in unique_lines:
-                        # Log each line directly using the logger to avoid nested formatting
-                        if verbosity > 0:
-                            # Remove any existing timestamp prefix to avoid duplication
-                            clean_line = line
-                            if "] " in line and line.startswith("2025-"):
-                                # Extract just the log message after the timestamp and level
-                                parts = line.split("] ", 1)
-                                if len(parts) > 1:
-                                    clean_line = parts[1]
-                            logger.debug(clean_line)
-
-            # Provide context about common execution errors
-            if "list can't be used in 'await' expression" in str(e):
-                logger.info("This appears to be an async/await mismatch in a component")
-                logger.info("Check that async methods are properly awaited")
-            elif "AttributeError" in error_type and "NoneType" in str(e):
-                logger.info("This appears to be a null reference error")
-                logger.info("A component may be receiving unexpected None values")
-            elif "ConnectionError" in str(e) or "TimeoutError" in str(e):
-                logger.info("This appears to be a network connectivity issue")
-                logger.info("Check API keys and network connectivity")
-
-            logger.exception("Failed to execute graph - full traceback:")
-
-        if temp_file_to_cleanup:
-            try:
-                Path(temp_file_to_cleanup).unlink()
-                logger.info(f"Cleaned up temporary file: {temp_file_to_cleanup}")
-            except OSError:
-                pass
-        sys.stdout = original_stdout
-        sys.stderr = original_stderr
-        output_error(f"Failed to execute graph: {e}", verbose=verbosity > 0, exception=e)
+            error_response["exception_message"] = str(e)
+        typer.echo(json.dumps(error_response))
         raise typer.Exit(1) from e
-    finally:
-        sys.stdout = original_stdout
-        sys.stderr = original_stderr
-        if temp_file_to_cleanup:
-            try:
-                Path(temp_file_to_cleanup).unlink()
-                logger.info(f"Cleaned up temporary file: {temp_file_to_cleanup}")
-            except OSError:
-                pass
-
-    execution_end_time = time.time() if timing else None
-
-    captured_logs = captured_stdout.getvalue() + captured_stderr.getvalue()
-
-    # Create timing metadata if requested
-    timing_metadata = None
-    if timing:
-        load_duration = load_end_time - start_time
-        execution_duration = execution_end_time - execution_start_time
-        total_duration = execution_end_time - start_time
-
-        timing_metadata = {
-            "load_time": round(load_duration, 3),
-            "execution_time": round(execution_duration, 3),
-            "total_time": round(total_duration, 3),
-            "component_timings": [
-                {
-                    "component": ct["component"],
-                    "component_id": ct["component_id"],
-                    "duration": round(ct["duration"], 3),
-                    "cumulative_time": round(ct["cumulative_time"], 3),
-                }
-                for ct in component_timings
-            ],
-        }
-
-    if output_format == "json":
-        result_data = extract_structured_result(results)
-        result_data["logs"] = captured_logs
-        if timing_metadata:
-            result_data["timing"] = timing_metadata
-        indent = 2 if verbosity > 0 else None
-        typer.echo(json.dumps(result_data, indent=indent))
-    elif output_format in {"text", "message"}:
-        result_data = extract_structured_result(results)
-        output_text = result_data.get("result", result_data.get("text", ""))
-        typer.echo(str(output_text))
-    elif output_format == "result":
-        typer.echo(extract_text_from_result(results))
-    else:
-        result_data = extract_structured_result(results)
-        result_data["logs"] = captured_logs
-        if timing_metadata:
-            result_data["timing"] = timing_metadata
-        indent = 2 if verbosity > 0 else None
-        typer.echo(json.dumps(result_data, indent=indent))

lfx/cli/script_loader.py

@@ -36,15 +36,25 @@ def temporary_sys_path(path: str):
 
 def _load_module_from_script(script_path: Path) -> Any:
     """Load a Python module from a script file."""
-    spec = importlib.util.spec_from_file_location("script_module", script_path)
+    # Use the script name as the module name to allow inspect to find it
+    module_name = script_path.stem
+    spec = importlib.util.spec_from_file_location(module_name, script_path)
     if spec is None or spec.loader is None:
         msg = f"Could not create module spec for '{script_path}'"
         raise ImportError(msg)
 
     module = importlib.util.module_from_spec(spec)
 
-    with temporary_sys_path(str(script_path.parent)):
-        spec.loader.exec_module(module)
+    # Register in sys.modules so inspect.getmodule works
+    sys.modules[module_name] = module
+
+    try:
+        with temporary_sys_path(str(script_path.parent)):
+            spec.loader.exec_module(module)
+    except Exception:
+        if module_name in sys.modules:
+            del sys.modules[module_name]
+        raise
 
     return module
 

lfx/components/__init__.py

@@ -64,7 +64,6 @@ if TYPE_CHECKING:
         mem0,
         milvus,
         mistral,
-        models,
         models_and_agents,
         mongodb,
         needle,
@@ -168,7 +167,6 @@ _dynamic_imports = {
     "mem0": "__module__",
     "milvus": "__module__",
     "mistral": "__module__",
-    "models": "__module__",
     "models_and_agents": "__module__",
     "mongodb": "__module__",
     "needle": "__module__",
@@ -300,7 +298,6 @@ __all__ = [
     "mem0",
     "milvus",
     "mistral",
-    "models",
     "models_and_agents",
     "mongodb",
     "needle",