lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/components/confluence/confluence.py

@@ -0,0 +1,84 @@
+from langchain_community.document_loaders import ConfluenceLoader
+from langchain_community.document_loaders.confluence import ContentFormat
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import BoolInput, DropdownInput, IntInput, Output, SecretStrInput, StrInput
+from lfx.schema.data import Data
+
+
+class ConfluenceComponent(Component):
+    display_name = "Confluence"
+    description = "Confluence wiki collaboration platform"
+    documentation = "https://python.langchain.com/v0.2/docs/integrations/document_loaders/confluence/"
+    trace_type = "tool"
+    icon = "Confluence"
+    name = "Confluence"
+
+    inputs = [
+        StrInput(
+            name="url",
+            display_name="Site URL",
+            required=True,
+            info="The base URL of the Confluence Space. Example: https://<company>.atlassian.net/wiki.",
+        ),
+        StrInput(
+            name="username",
+            display_name="Username",
+            required=True,
+            info="Atlassian User E-mail. Example: email@example.com",
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="API Key",
+            required=True,
+            info="Atlassian Key. Create at: https://id.atlassian.com/manage-profile/security/api-tokens",
+        ),
+        StrInput(name="space_key", display_name="Space Key", required=True),
+        BoolInput(name="cloud", display_name="Use Cloud?", required=True, value=True, advanced=True),
+        DropdownInput(
+            name="content_format",
+            display_name="Content Format",
+            options=[
+                ContentFormat.EDITOR.value,
+                ContentFormat.EXPORT_VIEW.value,
+                ContentFormat.ANONYMOUS_EXPORT_VIEW.value,
+                ContentFormat.STORAGE.value,
+                ContentFormat.VIEW.value,
+            ],
+            value=ContentFormat.STORAGE.value,
+            required=True,
+            advanced=True,
+            info="Specify content format, defaults to ContentFormat.STORAGE",
+        ),
+        IntInput(
+            name="max_pages",
+            display_name="Max Pages",
+            required=False,
+            value=1000,
+            advanced=True,
+            info="Maximum number of pages to retrieve in total, defaults 1000",
+        ),
+    ]
+
+    outputs = [
+        Output(name="data", display_name="Data", method="load_documents"),
+    ]
+
+    def build_confluence(self) -> ConfluenceLoader:
+        content_format = ContentFormat(self.content_format)
+        return ConfluenceLoader(
+            url=self.url,
+            username=self.username,
+            api_key=self.api_key,
+            cloud=self.cloud,
+            space_key=self.space_key,
+            content_format=content_format,
+            max_pages=self.max_pages,
+        )
+
+    def load_documents(self) -> list[Data]:
+        confluence = self.build_confluence()
+        documents = confluence.load()
+        data = [Data.from_document(doc) for doc in documents]  # Using the from_document method of Data
+        self.status = data
+        return data

lfx/components/couchbase/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .couchbase import CouchbaseVectorStoreComponent
+
+_dynamic_imports = {
+    "CouchbaseVectorStoreComponent": "couchbase",
+}
+
+__all__ = [
+    "CouchbaseVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Couchbase 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__)

lfx/components/couchbase/couchbase.py

@@ -0,0 +1,102 @@
+from datetime import timedelta
+
+from langchain_community.vectorstores import CouchbaseVectorStore
+
+from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
+from lfx.helpers.data import docs_to_data
+from lfx.io import HandleInput, IntInput, SecretStrInput, StrInput
+from lfx.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 []

lfx/components/crewai/__init__.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.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__)

lfx/components/crewai/crewai.py

@@ -0,0 +1,107 @@
+from lfx.base.agents.crewai.crew import convert_llm, convert_tools
+from lfx.custom.custom_component.component import Component
+from lfx.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

lfx/components/crewai/hierarchical_crew.py

@@ -0,0 +1,46 @@
+from lfx.base.agents.crewai.crew import BaseCrewComponent
+from lfx.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.get_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(),
+        )

lfx/components/crewai/hierarchical_task.py

@@ -0,0 +1,44 @@
+from lfx.base.agents.crewai.tasks import HierarchicalTask
+from lfx.custom.custom_component.component import Component
+from lfx.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

lfx/components/crewai/sequential_crew.py

@@ -0,0 +1,52 @@
+from lfx.base.agents.crewai.crew import BaseCrewComponent
+from lfx.io import HandleInput
+from lfx.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.get_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(),
+        )

lfx/components/crewai/sequential_task.py

@@ -0,0 +1,73 @@
+from lfx.base.agents.crewai.tasks import SequentialTask
+from lfx.custom.custom_component.component import Component
+from lfx.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