langflow-base-nightly 0.5.1.dev2__py3-none-any.whl → 0.5.1.dev4__py3-none-any.whl

langflow/components/couchbase/couchbase.py

@@ -1,102 +0,0 @@
-from datetime import timedelta
-
-from langchain_community.vectorstores import CouchbaseVectorStore
-
-from langflow.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
-from langflow.helpers.data import docs_to_data
-from langflow.io import HandleInput, IntInput, SecretStrInput, StrInput
-from langflow.schema.data import Data
-
-
-class CouchbaseVectorStoreComponent(LCVectorStoreComponent):
-    display_name = "Couchbase"
-    description = "Couchbase Vector Store with search capabilities"
-    name = "Couchbase"
-    icon = "Couchbase"
-
-    inputs = [
-        SecretStrInput(
-            name="couchbase_connection_string", display_name="Couchbase Cluster connection string", required=True
-        ),
-        StrInput(name="couchbase_username", display_name="Couchbase username", required=True),
-        SecretStrInput(name="couchbase_password", display_name="Couchbase password", required=True),
-        StrInput(name="bucket_name", display_name="Bucket Name", required=True),
-        StrInput(name="scope_name", display_name="Scope Name", required=True),
-        StrInput(name="collection_name", display_name="Collection Name", required=True),
-        StrInput(name="index_name", display_name="Index Name", required=True),
-        *LCVectorStoreComponent.inputs,
-        HandleInput(name="embedding", display_name="Embedding", input_types=["Embeddings"]),
-        IntInput(
-            name="number_of_results",
-            display_name="Number of Results",
-            info="Number of results to return.",
-            value=4,
-            advanced=True,
-        ),
-    ]
-
-    @check_cached_vector_store
-    def build_vector_store(self) -> CouchbaseVectorStore:
-        try:
-            from couchbase.auth import PasswordAuthenticator
-            from couchbase.cluster import Cluster
-            from couchbase.options import ClusterOptions
-        except ImportError as e:
-            msg = "Failed to import Couchbase dependencies. Install it using `uv pip install langflow[couchbase] --pre`"
-            raise ImportError(msg) from e
-
-        try:
-            auth = PasswordAuthenticator(self.couchbase_username, self.couchbase_password)
-            options = ClusterOptions(auth)
-            cluster = Cluster(self.couchbase_connection_string, options)
-
-            cluster.wait_until_ready(timedelta(seconds=5))
-        except Exception as e:
-            msg = f"Failed to connect to Couchbase: {e}"
-            raise ValueError(msg) from e
-
-        self.ingest_data = self._prepare_ingest_data()
-
-        documents = []
-        for _input in self.ingest_data or []:
-            if isinstance(_input, Data):
-                documents.append(_input.to_lc_document())
-            else:
-                documents.append(_input)
-
-        if documents:
-            couchbase_vs = CouchbaseVectorStore.from_documents(
-                documents=documents,
-                cluster=cluster,
-                bucket_name=self.bucket_name,
-                scope_name=self.scope_name,
-                collection_name=self.collection_name,
-                embedding=self.embedding,
-                index_name=self.index_name,
-            )
-
-        else:
-            couchbase_vs = CouchbaseVectorStore(
-                cluster=cluster,
-                bucket_name=self.bucket_name,
-                scope_name=self.scope_name,
-                collection_name=self.collection_name,
-                embedding=self.embedding,
-                index_name=self.index_name,
-            )
-
-        return couchbase_vs
-
-    def search_documents(self) -> list[Data]:
-        vector_store = self.build_vector_store()
-
-        if self.search_query and isinstance(self.search_query, str) and self.search_query.strip():
-            docs = vector_store.similarity_search(
-                query=self.search_query,
-                k=self.number_of_results,
-            )
-
-            data = docs_to_data(docs)
-            self.status = data
-            return data
-        return []

langflow/components/crewai/__init__.py

@@ -1,49 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from .crewai import CrewAIAgentComponent
-    from .hierarchical_crew import HierarchicalCrewComponent
-    from .hierarchical_task import HierarchicalTaskComponent
-    from .sequential_crew import SequentialCrewComponent
-    from .sequential_task import SequentialTaskComponent
-    from .sequential_task_agent import SequentialTaskAgentComponent
-
-_dynamic_imports = {
-    "CrewAIAgentComponent": "crewai",
-    "HierarchicalCrewComponent": "hierarchical_crew",
-    "HierarchicalTaskComponent": "hierarchical_task",
-    "SequentialCrewComponent": "sequential_crew",
-    "SequentialTaskAgentComponent": "sequential_task_agent",
-    "SequentialTaskComponent": "sequential_task",
-}
-
-__all__ = [
-    "CrewAIAgentComponent",
-    "HierarchicalCrewComponent",
-    "HierarchicalTaskComponent",
-    "SequentialCrewComponent",
-    "SequentialTaskAgentComponent",
-    "SequentialTaskComponent",
-]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import crewai components on attribute access."""
-    if attr_name not in _dynamic_imports:
-        msg = f"module '{__name__}' has no attribute '{attr_name}'"
-        raise AttributeError(msg)
-    try:
-        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
-    except (ModuleNotFoundError, ImportError, AttributeError) as e:
-        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
-        raise AttributeError(msg) from e
-    globals()[attr_name] = result
-    return result
-
-
-def __dir__() -> list[str]:
-    return list(__all__)

langflow/components/crewai/crewai.py

@@ -1,107 +0,0 @@
-from langflow.base.agents.crewai.crew import convert_llm, convert_tools
-from langflow.custom.custom_component.component import Component
-from langflow.io import BoolInput, DictInput, HandleInput, MultilineInput, Output
-
-
-class CrewAIAgentComponent(Component):
-    """Component for creating a CrewAI agent.
-
-    This component allows you to create a CrewAI agent with the specified role, goal, backstory, tools,
-    and language model.
-
-    Args:
-        Component (Component): Base class for all components.
-
-    Returns:
-        Agent: CrewAI agent.
-    """
-
-    display_name = "CrewAI Agent"
-    description = "Represents an agent of CrewAI."
-    documentation: str = "https://docs.crewai.com/how-to/LLM-Connections/"
-    icon = "CrewAI"
-    legacy = True
-
-    inputs = [
-        MultilineInput(name="role", display_name="Role", info="The role of the agent."),
-        MultilineInput(name="goal", display_name="Goal", info="The objective of the agent."),
-        MultilineInput(name="backstory", display_name="Backstory", info="The backstory of the agent."),
-        HandleInput(
-            name="tools",
-            display_name="Tools",
-            input_types=["Tool"],
-            is_list=True,
-            info="Tools at agents disposal",
-            value=[],
-        ),
-        HandleInput(
-            name="llm",
-            display_name="Language Model",
-            info="Language model that will run the agent.",
-            input_types=["LanguageModel"],
-        ),
-        BoolInput(
-            name="memory",
-            display_name="Memory",
-            info="Whether the agent should have memory or not",
-            advanced=True,
-            value=True,
-        ),
-        BoolInput(
-            name="verbose",
-            display_name="Verbose",
-            advanced=True,
-            value=False,
-        ),
-        BoolInput(
-            name="allow_delegation",
-            display_name="Allow Delegation",
-            info="Whether the agent is allowed to delegate tasks to other agents.",
-            value=True,
-        ),
-        BoolInput(
-            name="allow_code_execution",
-            display_name="Allow Code Execution",
-            info="Whether the agent is allowed to execute code.",
-            value=False,
-            advanced=True,
-        ),
-        DictInput(
-            name="kwargs",
-            display_name="kwargs",
-            info="kwargs of agent.",
-            is_list=True,
-            advanced=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Agent", name="output", method="build_output"),
-    ]
-
-    def build_output(self):
-        try:
-            from crewai import Agent
-        except ImportError as e:
-            msg = "CrewAI is not installed. Please install it with `uv pip install crewai`."
-            raise ImportError(msg) from e
-
-        kwargs = self.kwargs or {}
-
-        # Define the Agent
-        agent = Agent(
-            role=self.role,
-            goal=self.goal,
-            backstory=self.backstory,
-            llm=convert_llm(self.llm),
-            verbose=self.verbose,
-            memory=self.memory,
-            tools=convert_tools(self.tools),
-            allow_delegation=self.allow_delegation,
-            allow_code_execution=self.allow_code_execution,
-            **kwargs,
-        )
-
-        self.status = repr(agent)
-
-        return agent

langflow/components/crewai/hierarchical_crew.py

@@ -1,46 +0,0 @@
-from langflow.base.agents.crewai.crew import BaseCrewComponent
-from langflow.io import HandleInput
-
-
-class HierarchicalCrewComponent(BaseCrewComponent):
-    display_name: str = "Hierarchical Crew"
-    description: str = (
-        "Represents a group of agents, defining how they should collaborate and the tasks they should perform."
-    )
-    documentation: str = "https://docs.crewai.com/how-to/Hierarchical/"
-    icon = "CrewAI"
-    legacy = True
-
-    inputs = [
-        *BaseCrewComponent._base_inputs,
-        HandleInput(name="agents", display_name="Agents", input_types=["Agent"], is_list=True),
-        HandleInput(name="tasks", display_name="Tasks", input_types=["HierarchicalTask"], is_list=True),
-        HandleInput(name="manager_llm", display_name="Manager LLM", input_types=["LanguageModel"], required=False),
-        HandleInput(name="manager_agent", display_name="Manager Agent", input_types=["Agent"], required=False),
-    ]
-
-    def build_crew(self):
-        try:
-            from crewai import Crew, Process
-        except ImportError as e:
-            msg = "CrewAI is not installed. Please install it with `uv pip install crewai`."
-            raise ImportError(msg) from e
-
-        tasks, agents = self.get_tasks_and_agents()
-        manager_llm = self.get_manager_llm()
-
-        return Crew(
-            agents=agents,
-            tasks=tasks,
-            process=Process.hierarchical,
-            verbose=self.verbose,
-            memory=self.memory,
-            cache=self.use_cache,
-            max_rpm=self.max_rpm,
-            share_crew=self.share_crew,
-            function_calling_llm=self.function_calling_llm,
-            manager_agent=self.manager_agent,
-            manager_llm=manager_llm,
-            step_callback=self.get_step_callback(),
-            task_callback=self.get_task_callback(),
-        )

langflow/components/crewai/hierarchical_task.py

@@ -1,44 +0,0 @@
-from langflow.base.agents.crewai.tasks import HierarchicalTask
-from langflow.custom.custom_component.component import Component
-from langflow.io import HandleInput, MultilineInput, Output
-
-
-class HierarchicalTaskComponent(Component):
-    display_name: str = "Hierarchical Task"
-    description: str = "Each task must have a description, an expected output and an agent responsible for execution."
-    icon = "CrewAI"
-    legacy = True
-    inputs = [
-        MultilineInput(
-            name="task_description",
-            display_name="Description",
-            info="Descriptive text detailing task's purpose and execution.",
-        ),
-        MultilineInput(
-            name="expected_output",
-            display_name="Expected Output",
-            info="Clear definition of expected task outcome.",
-        ),
-        HandleInput(
-            name="tools",
-            display_name="Tools",
-            input_types=["Tool"],
-            is_list=True,
-            info="List of tools/resources limited for task execution. Uses the Agent tools by default.",
-            required=False,
-            advanced=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Task", name="task_output", method="build_task"),
-    ]
-
-    def build_task(self) -> HierarchicalTask:
-        task = HierarchicalTask(
-            description=self.task_description,
-            expected_output=self.expected_output,
-            tools=self.tools or [],
-        )
-        self.status = task
-        return task

langflow/components/crewai/sequential_crew.py

@@ -1,52 +0,0 @@
-from langflow.base.agents.crewai.crew import BaseCrewComponent
-from langflow.io import HandleInput
-from langflow.schema.message import Message
-
-
-class SequentialCrewComponent(BaseCrewComponent):
-    display_name: str = "Sequential Crew"
-    description: str = "Represents a group of agents with tasks that are executed sequentially."
-    documentation: str = "https://docs.crewai.com/how-to/Sequential/"
-    icon = "CrewAI"
-    legacy = True
-
-    inputs = [
-        *BaseCrewComponent._base_inputs,
-        HandleInput(name="tasks", display_name="Tasks", input_types=["SequentialTask"], is_list=True),
-    ]
-
-    @property
-    def agents(self: "SequentialCrewComponent") -> list:
-        # Derive agents directly from linked tasks
-        return [task.agent for task in self.tasks if hasattr(task, "agent")]
-
-    def get_tasks_and_agents(self, agents_list=None) -> tuple[list, list]:
-        # Use the agents property to derive agents
-        if not agents_list:
-            existing_agents = self.agents
-            agents_list = existing_agents + (agents_list or [])
-
-        return super().get_tasks_and_agents(agents_list=agents_list)
-
-    def build_crew(self) -> Message:
-        try:
-            from crewai import Crew, Process
-        except ImportError as e:
-            msg = "CrewAI is not installed. Please install it with `uv pip install crewai`."
-            raise ImportError(msg) from e
-
-        tasks, agents = self.get_tasks_and_agents()
-
-        return Crew(
-            agents=agents,
-            tasks=tasks,
-            process=Process.sequential,
-            verbose=self.verbose,
-            memory=self.memory,
-            cache=self.use_cache,
-            max_rpm=self.max_rpm,
-            share_crew=self.share_crew,
-            function_calling_llm=self.function_calling_llm,
-            step_callback=self.get_step_callback(),
-            task_callback=self.get_task_callback(),
-        )

langflow/components/crewai/sequential_task.py

@@ -1,73 +0,0 @@
-from langflow.base.agents.crewai.tasks import SequentialTask
-from langflow.custom.custom_component.component import Component
-from langflow.io import BoolInput, HandleInput, MultilineInput, Output
-
-
-class SequentialTaskComponent(Component):
-    display_name: str = "Sequential Task"
-    description: str = "Each task must have a description, an expected output and an agent responsible for execution."
-    icon = "CrewAI"
-    legacy = True
-    inputs = [
-        MultilineInput(
-            name="task_description",
-            display_name="Description",
-            info="Descriptive text detailing task's purpose and execution.",
-        ),
-        MultilineInput(
-            name="expected_output",
-            display_name="Expected Output",
-            info="Clear definition of expected task outcome.",
-        ),
-        HandleInput(
-            name="tools",
-            display_name="Tools",
-            input_types=["Tool"],
-            is_list=True,
-            info="List of tools/resources limited for task execution. Uses the Agent tools by default.",
-            required=False,
-            advanced=True,
-        ),
-        HandleInput(
-            name="agent",
-            display_name="Agent",
-            input_types=["Agent"],
-            info="CrewAI Agent that will perform the task",
-            required=True,
-        ),
-        HandleInput(
-            name="task",
-            display_name="Task",
-            input_types=["SequentialTask"],
-            info="CrewAI Task that will perform the task",
-        ),
-        BoolInput(
-            name="async_execution",
-            display_name="Async Execution",
-            value=True,
-            advanced=True,
-            info="Boolean flag indicating asynchronous task execution.",
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Task", name="task_output", method="build_task"),
-    ]
-
-    def build_task(self) -> list[SequentialTask]:
-        tasks: list[SequentialTask] = []
-        task = SequentialTask(
-            description=self.task_description,
-            expected_output=self.expected_output,
-            tools=self.agent.tools,
-            async_execution=False,
-            agent=self.agent,
-        )
-        tasks.append(task)
-        self.status = task
-        if self.task:
-            if isinstance(self.task, list) and all(isinstance(task_item, SequentialTask) for task_item in self.task):
-                tasks = self.task + tasks
-            elif isinstance(self.task, SequentialTask):
-                tasks = [self.task, *tasks]
-        return tasks

langflow/components/crewai/sequential_task_agent.py

@@ -1,143 +0,0 @@
-from langflow.base.agents.crewai.tasks import SequentialTask
-from langflow.custom.custom_component.component import Component
-from langflow.io import BoolInput, DictInput, HandleInput, MultilineInput, Output
-
-
-class SequentialTaskAgentComponent(Component):
-    display_name = "Sequential Task Agent"
-    description = "Creates a CrewAI Task and its associated Agent."
-    documentation = "https://docs.crewai.com/how-to/LLM-Connections/"
-    icon = "CrewAI"
-    legacy = True
-
-    inputs = [
-        # Agent inputs
-        MultilineInput(name="role", display_name="Role", info="The role of the agent."),
-        MultilineInput(name="goal", display_name="Goal", info="The objective of the agent."),
-        MultilineInput(
-            name="backstory",
-            display_name="Backstory",
-            info="The backstory of the agent.",
-        ),
-        HandleInput(
-            name="tools",
-            display_name="Tools",
-            input_types=["Tool"],
-            is_list=True,
-            info="Tools at agent's disposal",
-            value=[],
-        ),
-        HandleInput(
-            name="llm",
-            display_name="Language Model",
-            info="Language model that will run the agent.",
-            input_types=["LanguageModel"],
-        ),
-        BoolInput(
-            name="memory",
-            display_name="Memory",
-            info="Whether the agent should have memory or not",
-            advanced=True,
-            value=True,
-        ),
-        BoolInput(
-            name="verbose",
-            display_name="Verbose",
-            advanced=True,
-            value=True,
-        ),
-        BoolInput(
-            name="allow_delegation",
-            display_name="Allow Delegation",
-            info="Whether the agent is allowed to delegate tasks to other agents.",
-            value=False,
-            advanced=True,
-        ),
-        BoolInput(
-            name="allow_code_execution",
-            display_name="Allow Code Execution",
-            info="Whether the agent is allowed to execute code.",
-            value=False,
-            advanced=True,
-        ),
-        DictInput(
-            name="agent_kwargs",
-            display_name="Agent kwargs",
-            info="Additional kwargs for the agent.",
-            is_list=True,
-            advanced=True,
-        ),
-        # Task inputs
-        MultilineInput(
-            name="task_description",
-            display_name="Task Description",
-            info="Descriptive text detailing task's purpose and execution.",
-        ),
-        MultilineInput(
-            name="expected_output",
-            display_name="Expected Task Output",
-            info="Clear definition of expected task outcome.",
-        ),
-        BoolInput(
-            name="async_execution",
-            display_name="Async Execution",
-            value=False,
-            advanced=True,
-            info="Boolean flag indicating asynchronous task execution.",
-        ),
-        # Chaining input
-        HandleInput(
-            name="previous_task",
-            display_name="Previous Task",
-            input_types=["SequentialTask"],
-            info="The previous task in the sequence (for chaining).",
-            required=False,
-        ),
-    ]
-
-    outputs = [
-        Output(
-            display_name="Sequential Task",
-            name="task_output",
-            method="build_agent_and_task",
-        ),
-    ]
-
-    def build_agent_and_task(self) -> list[SequentialTask]:
-        try:
-            from crewai import Agent, Task
-        except ImportError as e:
-            msg = "CrewAI is not installed. Please install it with `uv pip install crewai`."
-            raise ImportError(msg) from e
-
-        # Build the agent
-        agent_kwargs = self.agent_kwargs or {}
-        agent = Agent(
-            role=self.role,
-            goal=self.goal,
-            backstory=self.backstory,
-            llm=self.llm,
-            verbose=self.verbose,
-            memory=self.memory,
-            tools=self.tools or [],
-            allow_delegation=self.allow_delegation,
-            allow_code_execution=self.allow_code_execution,
-            **agent_kwargs,
-        )
-
-        # Build the task
-        task = Task(
-            description=self.task_description,
-            expected_output=self.expected_output,
-            agent=agent,
-            async_execution=self.async_execution,
-        )
-
-        # If there's a previous task, create a list of tasks
-        if self.previous_task:
-            tasks = [*self.previous_task, task] if isinstance(self.previous_task, list) else [self.previous_task, task]
-        else:
-            tasks = [task]
-
-        self.status = f"Agent: {agent!r}\nTask: {task!r}"
-        return tasks

langflow/components/custom_component/__init__.py

@@ -1,34 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from .custom_component import CustomComponent
-
-_dynamic_imports = {
-    "CustomComponent": "custom_component",
-}
-
-__all__ = [
-    "CustomComponent",
-]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import custom components on attribute access."""
-    if attr_name not in _dynamic_imports:
-        msg = f"module '{__name__}' has no attribute '{attr_name}'"
-        raise AttributeError(msg)
-    try:
-        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
-    except (ModuleNotFoundError, ImportError, AttributeError) as e:
-        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
-        raise AttributeError(msg) from e
-    globals()[attr_name] = result
-    return result
-
-
-def __dir__() -> list[str]:
-    return list(__all__)

langflow/components/custom_component/custom_component.py

@@ -1,31 +0,0 @@
-# from langflow.field_typing import Data
-from langflow.custom.custom_component.component import Component
-from langflow.io import MessageTextInput, Output
-from langflow.schema.data import Data
-
-
-class CustomComponent(Component):
-    display_name = "Custom Component"
-    description = "Use as a template to create your own component."
-    documentation: str = "https://docs.langflow.org/components-custom-components"
-    icon = "code"
-    name = "CustomComponent"
-
-    inputs = [
-        MessageTextInput(
-            name="input_value",
-            display_name="Input Value",
-            info="This is a custom component Input",
-            value="Hello, World!",
-            tool_mode=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Output", name="output", method="build_output"),
-    ]
-
-    def build_output(self) -> Data:
-        data = Data(value=self.input_value)
-        self.status = data
-        return data