lfx-nightly 0.2.0.dev0__py3-none-any.whl → 0.2.0.dev26__py3-none-any.whl

lfx/components/groq/groq.py

@@ -1,7 +1,7 @@
-import requests
 from pydantic.v1 import SecretStr
 
-from lfx.base.models.groq_constants import GROQ_MODELS, TOOL_CALLING_UNSUPPORTED_GROQ_MODELS, UNSUPPORTED_GROQ_MODELS
+from lfx.base.models.groq_constants import GROQ_MODELS
+from lfx.base.models.groq_model_discovery import get_groq_models
 from lfx.base.models.model import LCModelComponent
 from lfx.field_typing import LanguageModel
 from lfx.field_typing.range_spec import RangeSpec
@@ -52,7 +52,7 @@ class GroqModel(LCModelComponent):
         DropdownInput(
             name="model_name",
             display_name="Model",
-            info="The name of the model to use.",
+            info="The name of the model to use. Add your Groq API key to access additional available models.",
             options=GROQ_MODELS,
             value=GROQ_MODELS[0],
             refresh_button=True,
@@ -71,35 +71,42 @@ class GroqModel(LCModelComponent):
     ]
 
     def get_models(self, *, tool_model_enabled: bool | None = None) -> list[str]:
+        """Get available Groq models using the dynamic discovery system.
+
+        This method uses the groq_model_discovery module which:
+        - Fetches models directly from Groq API
+        - Automatically tests tool calling support
+        - Caches results for 24 hours
+        - Falls back to hardcoded list if API fails
+
+        Args:
+            tool_model_enabled: If True, only return models that support tool calling
+
+        Returns:
+            List of available model IDs
+        """
         try:
-            url = f"{self.base_url}/openai/v1/models"
-            headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+            # Get models with metadata from dynamic discovery system
+            api_key = self.api_key if hasattr(self, "api_key") and self.api_key else None
+            models_metadata = get_groq_models(api_key=api_key)
 
-            response = requests.get(url, headers=headers, timeout=10)
-            response.raise_for_status()
-            model_list = response.json()
+            # Filter out non-LLM models (audio, TTS, guards)
             model_ids = [
-                model["id"] for model in model_list.get("data", []) if model["id"] not in UNSUPPORTED_GROQ_MODELS
+                model_id for model_id, metadata in models_metadata.items() if not metadata.get("not_supported", False)
             ]
-        except (ImportError, ValueError, requests.exceptions.RequestException) as e:
+
+            # Filter by tool calling support if requested
+            if tool_model_enabled:
+                model_ids = [model_id for model_id in model_ids if models_metadata[model_id].get("tool_calling", False)]
+                logger.info(f"Loaded {len(model_ids)} Groq models with tool calling support")
+            else:
+                logger.info(f"Loaded {len(model_ids)} Groq models")
+        except (ValueError, KeyError, TypeError, ImportError) as e:
             logger.exception(f"Error getting model names: {e}")
-            model_ids = GROQ_MODELS
-        if tool_model_enabled:
-            try:
-                from langchain_groq import ChatGroq
-            except ImportError as e:
-                msg = "langchain_groq is not installed. Please install it with `pip install langchain_groq`."
-                raise ImportError(msg) from e
-            for model in model_ids:
-                model_with_tool = ChatGroq(
-                    model=model,
-                    api_key=self.api_key,
-                    base_url=self.base_url,
-                )
-                if not self.supports_tool_calling(model_with_tool) or model in TOOL_CALLING_UNSUPPORTED_GROQ_MODELS:
-                    model_ids.remove(model)
+            # Fallback to hardcoded list from groq_constants.py
+            return GROQ_MODELS
+        else:
             return model_ids
-        return model_ids
 
     def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
         if field_name in {"base_url", "model_name", "tool_model_enabled", "api_key"} and field_value:
@@ -107,13 +114,13 @@ class GroqModel(LCModelComponent):
                 if len(self.api_key) != 0:
                     try:
                         ids = self.get_models(tool_model_enabled=self.tool_model_enabled)
-                    except (ImportError, ValueError, requests.exceptions.RequestException) as e:
+                    except (ValueError, KeyError, TypeError, ImportError) as e:
                         logger.exception(f"Error getting model names: {e}")
                         ids = GROQ_MODELS
                     build_config.setdefault("model_name", {})
                     build_config["model_name"]["options"] = ids
                     build_config["model_name"].setdefault("value", ids[0])
-            except Exception as e:
+            except (ValueError, KeyError, TypeError, AttributeError) as e:
                 msg = f"Error getting model names: {e}"
                 raise ValueError(msg) from e
         return build_config

lfx/components/helpers/__init__.py

@@ -1,5 +1,8 @@
+"""Helpers module - backwards compatibility for moved components."""
+
 from __future__ import annotations
 
+import sys
 from typing import TYPE_CHECKING, Any
 
 from lfx.components._importing import import_mod
@@ -33,12 +36,111 @@ __all__ = [
     "OutputParserComponent",
 ]
 
+# Register redirected submodules in sys.modules for direct importlib.import_module() calls
+# This allows imports like: import lfx.components.helpers.current_date
+_redirected_submodules = {
+    "lfx.components.helpers.current_date": "lfx.components.utilities.current_date",
+    "lfx.components.helpers.calculator_core": "lfx.components.utilities.calculator_core",
+    "lfx.components.helpers.id_generator": "lfx.components.utilities.id_generator",
+    "lfx.components.helpers.memory": "lfx.components.models_and_agents.memory",
+}
+
+for old_path, new_path in _redirected_submodules.items():
+    if old_path not in sys.modules:
+        # Use a lazy loader that imports the actual module when accessed
+        class _RedirectedModule:
+            def __init__(self, target_path: str, original_path: str):
+                self._target_path = target_path
+                self._original_path = original_path
+                self._module = None
+
+            def __getattr__(self, name: str) -> Any:
+                if self._module is None:
+                    from importlib import import_module
+
+                    self._module = import_module(self._target_path)
+                    # Also register under the original path for future imports
+                    sys.modules[self._original_path] = self._module
+                return getattr(self._module, name)
+
+            def __repr__(self) -> str:
+                return f"<redirected module '{self._original_path}' -> '{self._target_path}'>"
+
+        sys.modules[old_path] = _RedirectedModule(new_path, old_path)
+
 
 def __getattr__(attr_name: str) -> Any:
     """Lazily import helper components on attribute access."""
+    # Handle submodule access for backwards compatibility
+    # e.g., lfx.components.helpers.id_generator -> lfx.components.utilities.id_generator
+    if attr_name == "id_generator":
+        from importlib import import_module
+
+        result = import_module("lfx.components.utilities.id_generator")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "calculator_core":
+        from importlib import import_module
+
+        result = import_module("lfx.components.utilities.calculator_core")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "current_date":
+        from importlib import import_module
+
+        result = import_module("lfx.components.utilities.current_date")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "memory":
+        from importlib import import_module
+
+        result = import_module("lfx.components.models_and_agents.memory")
+        globals()[attr_name] = result
+        return result
+
     if attr_name not in _dynamic_imports:
         msg = f"module '{__name__}' has no attribute '{attr_name}'"
         raise AttributeError(msg)
+
+    # CurrentDateComponent, CalculatorComponent, and IDGeneratorComponent were moved to utilities
+    # Forward them to utilities for backwards compatibility
+    if attr_name in ("CurrentDateComponent", "CalculatorComponent", "IDGeneratorComponent"):
+        from lfx.components import utilities
+
+        result = getattr(utilities, attr_name)
+        globals()[attr_name] = result
+        return result
+
+    # MemoryComponent was moved to models_and_agents
+    # Forward it to models_and_agents for backwards compatibility
+    if attr_name == "MemoryComponent":
+        from lfx.components import models_and_agents
+
+        result = getattr(models_and_agents, attr_name)
+        globals()[attr_name] = result
+        return result
+
+    # CreateListComponent, MessageStoreComponent, and OutputParserComponent were moved to processing
+    # Forward them to processing for backwards compatibility
+    if attr_name == "CreateListComponent":
+        from lfx.components import processing
+
+        result = getattr(processing, attr_name)
+        globals()[attr_name] = result
+        return result
+    if attr_name == "MessageStoreComponent":
+        from lfx.components import processing
+
+        result = processing.MessageStoreComponent
+        globals()[attr_name] = result
+        return result
+    if attr_name == "OutputParserComponent":
+        from lfx.components import processing
+
+        result = getattr(processing, attr_name)
+        globals()[attr_name] = result
+        return result
+
     try:
         result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
     except (ModuleNotFoundError, ImportError, AttributeError) as e:

lfx/components/input_output/__init__.py

@@ -9,15 +9,17 @@ if TYPE_CHECKING:
     from lfx.components.input_output.chat_output import ChatOutput
     from lfx.components.input_output.text import TextInputComponent
     from lfx.components.input_output.text_output import TextOutputComponent
+    from lfx.components.input_output.webhook import WebhookComponent
 
 _dynamic_imports = {
     "ChatInput": "chat",
     "ChatOutput": "chat_output",
     "TextInputComponent": "text",
     "TextOutputComponent": "text_output",
+    "WebhookComponent": "webhook",
 }
 
-__all__ = ["ChatInput", "ChatOutput", "TextInputComponent", "TextOutputComponent"]
+__all__ = ["ChatInput", "ChatOutput", "TextInputComponent", "TextOutputComponent", "WebhookComponent"]
 
 
 def __getattr__(attr_name: str) -> Any:

lfx/components/input_output/chat.py

@@ -19,7 +19,7 @@ from lfx.utils.constants import (
 class ChatInput(ChatComponent):
     display_name = "Chat Input"
     description = "Get chat inputs from the Playground."
-    documentation: str = "https://docs.langflow.org/components-io#chat-input"
+    documentation: str = "https://docs.langflow.org/chat-input-and-output"
     icon = "MessagesSquare"
     name = "ChatInput"
     minimized = True
@@ -89,15 +89,16 @@ class ChatInput(ChatComponent):
         # Filter out None/empty values
         files = [f for f in files if f is not None and f != ""]
 
+        session_id = self.session_id or self.graph.session_id or ""
         message = await Message.create(
             text=self.input_value,
             sender=self.sender,
             sender_name=self.sender_name,
-            session_id=self.session_id,
+            session_id=session_id,
             context_id=self.context_id,
             files=files,
         )
-        if self.session_id and isinstance(message, Message) and self.should_store_message:
+        if session_id and isinstance(message, Message) and self.should_store_message:
             stored_message = await self.send_message(
                 message,
             )

lfx/components/input_output/chat_output.py

@@ -22,7 +22,7 @@ from lfx.utils.constants import (
 class ChatOutput(ChatComponent):
     display_name = "Chat Output"
     description = "Display a chat message in the Playground."
-    documentation: str = "https://docs.langflow.org/components-io#chat-output"
+    documentation: str = "https://docs.langflow.org/chat-input-and-output"
     icon = "MessagesSquare"
     name = "ChatOutput"
     minimized = True
@@ -117,7 +117,7 @@ class ChatOutput(ChatComponent):
         source, _, display_name, source_id = self.get_properties_from_source_component()
 
         # Create or use existing Message object
-        if isinstance(self.input_value, Message):
+        if isinstance(self.input_value, Message) and not self.is_connected_to_chat_input():
             message = self.input_value
             # Update message properties
             message.text = text
@@ -127,13 +127,13 @@ class ChatOutput(ChatComponent):
         # Set message properties
         message.sender = self.sender
         message.sender_name = self.sender_name
-        message.session_id = self.session_id
+        message.session_id = self.session_id or self.graph.session_id or ""
         message.context_id = self.context_id
         message.flow_id = self.graph.flow_id if hasattr(self, "graph") else None
         message.properties.source = self._build_source(source_id, display_name, source)
 
         # Store message if needed
-        if self.session_id and self.should_store_message:
+        if message.session_id and self.should_store_message:
             stored_message = await self.send_message(message)
             self.message.value = stored_message
             message = stored_message

lfx/components/input_output/text.py

@@ -6,7 +6,7 @@ from lfx.schema.message import Message
 class TextInputComponent(TextComponent):
     display_name = "Text Input"
     description = "Get user text inputs."
-    documentation: str = "https://docs.langflow.org/components-io#text-input"
+    documentation: str = "https://docs.langflow.org/text-input-and-output"
     icon = "type"
     name = "TextInput"
 

lfx/components/input_output/text_output.py

@@ -6,7 +6,7 @@ from lfx.schema.message import Message
 class TextOutputComponent(TextComponent):
     display_name = "Text Output"
     description = "Sends text output via API."
-    documentation: str = "https://docs.langflow.org/components-io#text-output"
+    documentation: str = "https://docs.langflow.org/text-input-and-output"
     icon = "type"
     name = "TextOutput"
 

lfx/components/{data → input_output}/webhook.py

@@ -7,7 +7,7 @@ from lfx.schema.data import Data
 
 class WebhookComponent(Component):
     display_name = "Webhook"
-    documentation: str = "https://docs.langflow.org/components-data#webhook"
+    documentation: str = "https://docs.langflow.org/component-webhook"
     name = "Webhook"
     icon = "webhook"
 

lfx/components/knowledge_bases/__init__.py

@@ -1,12 +1,19 @@
+"""Knowledge bases module - backwards compatibility alias for files_and_knowledge.
+
+This module provides backwards compatibility by forwarding all imports
+to files_and_knowledge where the actual knowledge base components are located.
+"""
+
 from __future__ import annotations
 
+import sys
 from typing import TYPE_CHECKING, Any
 
 from lfx.components._importing import import_mod
 
 if TYPE_CHECKING:
-    from lfx.components.knowledge_bases.ingestion import KnowledgeIngestionComponent
-    from lfx.components.knowledge_bases.retrieval import KnowledgeRetrievalComponent
+    from lfx.components.files_and_knowledge.ingestion import KnowledgeIngestionComponent
+    from lfx.components.files_and_knowledge.retrieval import KnowledgeRetrievalComponent
 
 _dynamic_imports = {
     "KnowledgeIngestionComponent": "ingestion",
@@ -15,14 +22,61 @@ _dynamic_imports = {
 
 __all__ = ["KnowledgeIngestionComponent", "KnowledgeRetrievalComponent"]
 
+# Register redirected submodules in sys.modules for direct importlib.import_module() calls
+# This allows imports like: import lfx.components.knowledge_bases.ingestion
+_redirected_submodules = {
+    "lfx.components.knowledge_bases.ingestion": "lfx.components.files_and_knowledge.ingestion",
+    "lfx.components.knowledge_bases.retrieval": "lfx.components.files_and_knowledge.retrieval",
+}
+
+for old_path, new_path in _redirected_submodules.items():
+    if old_path not in sys.modules:
+        # Use a lazy loader that imports the actual module when accessed
+        class _RedirectedModule:
+            def __init__(self, target_path: str, original_path: str):
+                self._target_path = target_path
+                self._original_path = original_path
+                self._module = None
+
+            def __getattr__(self, name: str) -> Any:
+                if self._module is None:
+                    from importlib import import_module
+
+                    self._module = import_module(self._target_path)
+                    # Also register under the original path for future imports
+                    sys.modules[self._original_path] = self._module
+                return getattr(self._module, name)
+
+            def __repr__(self) -> str:
+                return f"<redirected module '{self._original_path}' -> '{self._target_path}'>"
+
+        sys.modules[old_path] = _RedirectedModule(new_path, old_path)
+
 
 def __getattr__(attr_name: str) -> Any:
-    """Lazily import input/output components on attribute access."""
+    """Forward attribute access to files_and_knowledge components."""
+    # Handle submodule access for backwards compatibility
+    if attr_name == "ingestion":
+        from importlib import import_module
+
+        result = import_module("lfx.components.files_and_knowledge.ingestion")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "retrieval":
+        from importlib import import_module
+
+        result = import_module("lfx.components.files_and_knowledge.retrieval")
+        globals()[attr_name] = result
+        return result
+
     if attr_name not in _dynamic_imports:
         msg = f"module '{__name__}' has no attribute '{attr_name}'"
         raise AttributeError(msg)
+
+    # Import from files_and_knowledge using the correct package path
+    package = "lfx.components.files_and_knowledge"
     try:
-        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+        result = import_mod(attr_name, _dynamic_imports[attr_name], package)
     except (ModuleNotFoundError, ImportError, AttributeError) as e:
         msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
         raise AttributeError(msg) from e
@@ -31,4 +85,5 @@ def __getattr__(attr_name: str) -> Any:
 
 
 def __dir__() -> list[str]:
+    """Return directory of available components."""
     return list(__all__)

lfx/components/langchain_utilities/character.py

@@ -10,7 +10,7 @@ from lfx.utils.util import unescape_string
 class CharacterTextSplitterComponent(LCTextSplitterComponent):
     display_name = "Character Text Splitter"
     description = "Split text by number of characters."
-    documentation = "https://docs.langflow.org/components/text-splitters#charactertextsplitter"
+    documentation = "https://docs.langflow.org/bundles-langchain"
     name = "CharacterTextSplitter"
     icon = "LangChain"
 

lfx/components/langchain_utilities/csv_agent.py

@@ -1,6 +1,9 @@
-from langchain_experimental.agents.agent_toolkits.csv.base import create_csv_agent
+import contextlib
+import tempfile
+from pathlib import Path
 
 from lfx.base.agents.agent import LCAgentComponent
+from lfx.base.data.storage_utils import read_file_bytes
 from lfx.field_typing import AgentExecutor
 from lfx.inputs.inputs import (
     DictInput,
@@ -10,7 +13,9 @@ from lfx.inputs.inputs import (
     MessageTextInput,
 )
 from lfx.schema.message import Message
+from lfx.services.deps import get_settings_service
 from lfx.template.field.base import Output
+from lfx.utils.async_helpers import run_until_complete
 
 
 class CSVAgentComponent(LCAgentComponent):
@@ -70,32 +75,60 @@ class CSVAgentComponent(LCAgentComponent):
         return self.path
 
     def build_agent_response(self) -> Message:
-        agent_kwargs = {
-            "verbose": self.verbose,
-            "allow_dangerous_code": True,
-        }
+        """Build and execute the CSV agent, returning the response."""
+        try:
+            from langchain_experimental.agents.agent_toolkits.csv.base import create_csv_agent
+        except ImportError as e:
+            msg = (
+                "langchain-experimental is not installed. Please install it with `pip install langchain-experimental`."
+            )
+            raise ImportError(msg) from e
 
-        agent_csv = create_csv_agent(
-            llm=self.llm,
-            path=self._path(),
-            agent_type=self.agent_type,
-            handle_parsing_errors=self.handle_parsing_errors,
-            pandas_kwargs=self.pandas_kwargs,
-            **agent_kwargs,
-        )
+        try:
+            agent_kwargs = {
+                "verbose": self.verbose,
+                "allow_dangerous_code": True,
+            }
+
+            # Get local path (downloads from S3 if needed)
+            local_path = self._get_local_path()
 
-        result = agent_csv.invoke({"input": self.input_value})
-        return Message(text=str(result["output"]))
+            agent_csv = create_csv_agent(
+                llm=self.llm,
+                path=local_path,
+                agent_type=self.agent_type,
+                handle_parsing_errors=self.handle_parsing_errors,
+                pandas_kwargs=self.pandas_kwargs,
+                **agent_kwargs,
+            )
+
+            result = agent_csv.invoke({"input": self.input_value})
+            return Message(text=str(result["output"]))
+
+        finally:
+            # Clean up temp file if created
+            self._cleanup_temp_file()
 
     def build_agent(self) -> AgentExecutor:
+        try:
+            from langchain_experimental.agents.agent_toolkits.csv.base import create_csv_agent
+        except ImportError as e:
+            msg = (
+                "langchain-experimental is not installed. Please install it with `pip install langchain-experimental`."
+            )
+            raise ImportError(msg) from e
+
         agent_kwargs = {
             "verbose": self.verbose,
             "allow_dangerous_code": True,
         }
 
+        # Get local path (downloads from S3 if needed)
+        local_path = self._get_local_path()
+
         agent_csv = create_csv_agent(
             llm=self.llm,
-            path=self._path(),
+            path=local_path,
             agent_type=self.agent_type,
             handle_parsing_errors=self.handle_parsing_errors,
             pandas_kwargs=self.pandas_kwargs,
@@ -104,4 +137,39 @@ class CSVAgentComponent(LCAgentComponent):
 
         self.status = Message(text=str(agent_csv))
 
+        # Note: Temp file will be cleaned up when the component is destroyed or
+        # when build_agent_response is called
         return agent_csv
+
+    def _get_local_path(self) -> str:
+        """Get a local file path, downloading from S3 storage if necessary.
+
+        Returns:
+            str: Local file path that can be used by LangChain
+        """
+        file_path = self._path()
+        settings = get_settings_service().settings
+
+        # If using S3 storage, download the file to temp
+        if settings.storage_type == "s3":
+            # Download from S3 to temp file
+            csv_bytes = run_until_complete(read_file_bytes(file_path))
+
+            # Create temp file with .csv extension
+            suffix = Path(file_path.split("/")[-1]).suffix or ".csv"
+            with tempfile.NamedTemporaryFile(mode="wb", suffix=suffix, delete=False) as tmp_file:
+                tmp_file.write(csv_bytes)
+                temp_path = tmp_file.name
+
+            # Store temp path for cleanup
+            self._temp_file_path = temp_path
+            return temp_path
+
+        # Local storage - return path as-is
+        return file_path
+
+    def _cleanup_temp_file(self) -> None:
+        """Clean up temporary file if one was created."""
+        if hasattr(self, "_temp_file_path"):
+            with contextlib.suppress(Exception):
+                Path(self._temp_file_path).unlink()  # Ignore cleanup errors

lfx/components/langchain_utilities/json_agent.py

@@ -1,13 +1,15 @@
+import contextlib
+import tempfile
 from pathlib import Path
 
 import yaml
 from langchain.agents import AgentExecutor
-from langchain_community.agent_toolkits import create_json_agent
-from langchain_community.agent_toolkits.json.toolkit import JsonToolkit
-from langchain_community.tools.json.tool import JsonSpec
 
 from lfx.base.agents.agent import LCAgentComponent
+from lfx.base.data.storage_utils import read_file_bytes
 from lfx.inputs.inputs import FileInput, HandleInput
+from lfx.services.deps import get_settings_service
+from lfx.utils.async_helpers import run_until_complete
 
 
 class JsonAgentComponent(LCAgentComponent):
@@ -32,14 +34,67 @@ class JsonAgentComponent(LCAgentComponent):
         ),
     ]
 
+    def _get_local_path(self) -> Path:
+        """Get a local file path, downloading from S3 storage if necessary.
+
+        Returns:
+            Path: Local file path that can be used by LangChain
+        """
+        file_path = self.path
+        settings = get_settings_service().settings
+
+        # If using S3 storage, download the file to temp
+        if settings.storage_type == "s3":
+            # Download from S3 to temp file
+            file_bytes = run_until_complete(read_file_bytes(file_path))
+
+            # Create temp file with appropriate extension
+            suffix = Path(file_path.split("/")[-1]).suffix or ".json"
+            with tempfile.NamedTemporaryFile(mode="wb", suffix=suffix, delete=False) as tmp_file:
+                tmp_file.write(file_bytes)
+                temp_path = tmp_file.name
+
+            # Store temp path for cleanup
+            self._temp_file_path = temp_path
+            return Path(temp_path)
+
+        # Local storage - return as Path
+        return Path(file_path)
+
+    def _cleanup_temp_file(self) -> None:
+        """Clean up temporary file if one was created."""
+        if hasattr(self, "_temp_file_path"):
+            with contextlib.suppress(Exception):
+                Path(self._temp_file_path).unlink()  # Ignore cleanup errors
+
     def build_agent(self) -> AgentExecutor:
-        path = Path(self.path)
-        if path.suffix in {"yaml", "yml"}:
-            with path.open(encoding="utf-8") as file:
-                yaml_dict = yaml.safe_load(file)
-            spec = JsonSpec(dict_=yaml_dict)
-        else:
-            spec = JsonSpec.from_file(path)
-        toolkit = JsonToolkit(spec=spec)
+        """Build the JSON agent executor."""
+        try:
+            from langchain_community.agent_toolkits import create_json_agent
+            from langchain_community.agent_toolkits.json.toolkit import JsonToolkit
+            from langchain_community.tools.json.tool import JsonSpec
+        except ImportError as e:
+            msg = "langchain-community is not installed. Please install it with `pip install langchain-community`."
+            raise ImportError(msg) from e
+
+        try:
+            # Get local path (downloads from S3 if needed)
+            path = self._get_local_path()
 
-        return create_json_agent(llm=self.llm, toolkit=toolkit, **self.get_agent_kwargs())
+            if path.suffix in {".yaml", ".yml"}:
+                with path.open(encoding="utf-8") as file:
+                    yaml_dict = yaml.safe_load(file)
+                spec = JsonSpec(dict_=yaml_dict)
+            else:
+                spec = JsonSpec.from_file(str(path))
+            toolkit = JsonToolkit(spec=spec)
+
+            agent = create_json_agent(llm=self.llm, toolkit=toolkit, **self.get_agent_kwargs())
+        except Exception:
+            # Make sure to clean up temp file on error
+            self._cleanup_temp_file()
+            raise
+        else:
+            # Clean up temp file after agent is created
+            self._cleanup_temp_file()
+            return agent