merge fix

.env.example

@@ -56,6 +56,14 @@ LANGFLOW_REMOVE_API_KEYS=
 # LANGFLOW_REDIS_CACHE_EXPIRE (default: 3600)
 LANGFLOW_CACHE_TYPE=
 
+# Auto login
+# If set to true then a superuser will be logged in automatically
+# and the login page will be skipped, keeping the
+# default experience of Langflow
+# Values: true, false
+# Example: LANGFLOW_AUTO_LOGIN=true
+LANGFLOW_AUTO_LOGIN=
+
 # Superuser username
 # Example: LANGFLOW_SUPERUSER=admin
 LANGFLOW_SUPERUSER=

Dockerfile

@@ -12,4 +12,4 @@ WORKDIR $HOME/app
 COPY --chown=user . $HOME/app
 
 RUN pip install langflow>==0.0.86 -U --user
-CMD ["python", "-m", "langflow", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["python", "-m", "langflow", "run", "--host", "0.0.0.0", "--port", "7860"]

Makefile

@@ -22,6 +22,13 @@ tests:
 	@make install_backend
 	poetry run pytest tests
 
+tests_frontend:
+ifeq ($(UI), true)
+		cd src/frontend && ./run-tests.sh --ui
+else
+		cd src/frontend && ./run-tests.sh
+endif
+
 format:
 	poetry run black .
 	poetry run ruff . --fix

docs/docs/index.mdx

@@ -7,10 +7,11 @@ import useBaseUrl from "@docusaurus/useBaseUrl";
 import ZoomableImage from "/src/theme/ZoomableImage.js";
 
 {" "}
+
 <ZoomableImage
   alt="Docusaurus themed image"
   sources={{
-    light: "img/new_langflow2.gif",
+    light: "img/new_langflow.gif",
   }}
   style={{ width: "100%" }}
 />

pyproject.toml

@@ -90,6 +90,7 @@ langfuse = "^1.0.13"
 pillow = "^10.0.0"
 metal-sdk = "^2.2.0"
 markupsafe = "^2.1.3"
+numexpr = "^2.8.6"
 
 
 [tool.poetry.group.dev.dependencies]

src/backend/langflow/api/v1/chat.py

@@ -187,14 +187,18 @@ async def stream_build(
                     valid = False
                     update_build_status(cache_service, flow_id, BuildStatus.FAILURE)
 
-                response = {
-                    "valid": valid,
-                    "params": params,
-                    "id": vertex.id,
-                    "progress": round(i / number_of_nodes, 2),
-                }
+                vertex_id = (
+                    vertex.parent_node_id if vertex.parent_is_top_level else vertex.id
+                )
+                if vertex_id in graph.top_level_nodes:
+                    response = {
+                        "valid": valid,
+                        "params": params,
+                        "id": vertex_id,
+                        "progress": round(i / number_of_nodes, 2),
+                    }
 
-                yield str(StreamData(event="message", data=response))
+                    yield str(StreamData(event="message", data=response))
 
             langchain_object = graph.build()
             # Now we  need to check the input_keys to send them to the client

src/backend/langflow/api/v1/endpoints.py

@@ -69,7 +69,7 @@ def get_all(
     "/process/{flow_id}",
     response_model=ProcessResponse,
 )
-async def process_flow(
+async def process(
     session: Annotated[Session, Depends(get_session)],
     flow_id: str,
     inputs: Optional[dict] = None,

src/backend/langflow/components/llms/HuggingFaceEndpoints.py

@@ -1,6 +1,6 @@
 from typing import Optional
 from langflow import CustomComponent
-from langchain.llms import HuggingFaceEndpoint
+from langchain.llms.huggingface_endpoint import HuggingFaceEndpoint
 from langchain.llms.base import BaseLLM
 
 
@@ -13,7 +13,6 @@ class HuggingFaceEndpointsComponent(CustomComponent):
             "endpoint_url": {"display_name": "Endpoint URL", "password": True},
             "task": {
                 "display_name": "Task",
-                "type": "select",
                 "options": ["text2text-generation", "text-generation", "summarization"],
             },
             "huggingfacehub_api_token": {"display_name": "API token", "password": True},
@@ -27,7 +26,7 @@ class HuggingFaceEndpointsComponent(CustomComponent):
     def build(
         self,
         endpoint_url: str,
-        task="text2text-generation",
+        task: str = "text2text-generation",
         huggingfacehub_api_token: Optional[str] = None,
         model_kwargs: Optional[dict] = None,
     ) -> BaseLLM:
@@ -36,6 +35,7 @@ class HuggingFaceEndpointsComponent(CustomComponent):
                 endpoint_url=endpoint_url,
                 task=task,
                 huggingfacehub_api_token=huggingfacehub_api_token,
+                model_kwargs=model_kwargs,
             )
         except Exception as e:
             raise ValueError("Could not connect to HuggingFace Endpoints API.") from e

src/backend/langflow/components/vectorstores/Vectara.py

@@ -5,7 +5,6 @@ from langchain.vectorstores import Vectara
 from langchain.schema import Document
 from langchain.vectorstores.base import VectorStore
 from langchain.schema import BaseRetriever
-from langchain.embeddings.base import Embeddings
 
 
 class VectaraComponent(CustomComponent):
@@ -22,7 +21,6 @@ class VectaraComponent(CustomComponent):
         "vectara_api_key": {"display_name": "Vectara API Key", "password": True},
         "code": {"show": False},
         "documents": {"display_name": "Documents"},
-        "embedding": {"display_name": "Embedding"},
     }
 
     def build(
@@ -30,21 +28,21 @@ class VectaraComponent(CustomComponent):
         vectara_customer_id: str,
         vectara_corpus_id: str,
         vectara_api_key: str,
-        embedding: Optional[Embeddings] = None,
         documents: Optional[Document] = None,
     ) -> Union[VectorStore, BaseRetriever]:
         # If documents, then we need to create a Vectara instance using .from_documents
-        if documents is not None and embedding is not None:
+        if documents is not None:
             return Vectara.from_documents(
                 documents=documents,  # type: ignore
                 vectara_customer_id=vectara_customer_id,
                 vectara_corpus_id=vectara_corpus_id,
                 vectara_api_key=vectara_api_key,
-                embedding=embedding,
+                source="langflow",
             )
 
         return Vectara(
             vectara_customer_id=vectara_customer_id,
             vectara_corpus_id=vectara_corpus_id,
             vectara_api_key=vectara_api_key,
+            source="langflow",
         )

src/backend/langflow/field_typing/__init__.py

@@ -1,3 +1,53 @@
-from .base import NestedDict
+# LANGCHAIN_BASE_TYPES = {
+#     "Chain": Chain,
+#     "AgentExecutor": AgentExecutor,
+#     "Tool": Tool,
+#     "BaseLLM": BaseLLM,
+#     "PromptTemplate": PromptTemplate,
+#     "BaseLoader": BaseLoader,
+#     "Document": Document,
+#     "TextSplitter": TextSplitter,
+#     "VectorStore": VectorStore,
+#     "Embeddings": Embeddings,
+#     "BaseRetriever": BaseRetriever,
+#     "BaseOutputParser": BaseOutputParser,
+#     "BaseMemory": BaseMemory,
+#     "BaseChatMemory": BaseChatMemory,
+# }
+from .constants import (
+    Tool,
+    PromptTemplate,
+    Chain,
+    BaseChatMemory,
+    BaseLLM,
+    BaseLoader,
+    BaseMemory,
+    BaseOutputParser,
+    BaseRetriever,
+    VectorStore,
+    Embeddings,
+    TextSplitter,
+    Document,
+    AgentExecutor,
+    NestedDict,
+    Data,
+)
 
-__all__ = ["NestedDict"]
+__all__ = [
+    "NestedDict",
+    "Data",
+    "Tool",
+    "PromptTemplate",
+    "Chain",
+    "BaseChatMemory",
+    "BaseLLM",
+    "BaseLoader",
+    "BaseMemory",
+    "BaseOutputParser",
+    "BaseRetriever",
+    "VectorStore",
+    "Embeddings",
+    "TextSplitter",
+    "Document",
+    "AgentExecutor",
+]

src/backend/langflow/field_typing/base.py

@@ -1,4 +0,0 @@
-from typing import Union, Dict
-
-# Type alias for more complex dicts
-NestedDict = Dict[str, Union[str, Dict]]

src/backend/langflow/field_typing/constants.py

@@ -0,0 +1,50 @@
+from langchain.agents.agent import AgentExecutor
+from langchain.chains.base import Chain
+from langchain.document_loaders.base import BaseLoader
+from langchain.llms.base import BaseLLM
+from langchain.memory.chat_memory import BaseChatMemory
+from langchain.prompts import PromptTemplate
+from langchain.schema import BaseOutputParser, BaseRetriever, Document
+from langchain.schema.embeddings import Embeddings
+from langchain.schema.memory import BaseMemory
+from langchain.text_splitter import TextSplitter
+from langchain.tools import Tool
+from langchain.vectorstores.base import VectorStore
+from typing import Union, Dict
+
+# Type alias for more complex dicts
+NestedDict = Dict[str, Union[str, Dict]]
+
+
+class Data:
+    pass
+
+
+LANGCHAIN_BASE_TYPES = {
+    "Chain": Chain,
+    "AgentExecutor": AgentExecutor,
+    "Tool": Tool,
+    "BaseLLM": BaseLLM,
+    "PromptTemplate": PromptTemplate,
+    "BaseLoader": BaseLoader,
+    "Document": Document,
+    "TextSplitter": TextSplitter,
+    "VectorStore": VectorStore,
+    "Embeddings": Embeddings,
+    "BaseRetriever": BaseRetriever,
+    "BaseOutputParser": BaseOutputParser,
+    "BaseMemory": BaseMemory,
+    "BaseChatMemory": BaseChatMemory,
+}
+# Langchain base types plus Python base types
+CUSTOM_COMPONENT_SUPPORTED_TYPES = {
+    **LANGCHAIN_BASE_TYPES,
+    "str": str,
+    "int": int,
+    "float": float,
+    "bool": bool,
+    "list": list,
+    "dict": dict,
+    "NestedDict": NestedDict,
+    "Data": Data,
+}

src/backend/langflow/graph/edge/base.py

@@ -1,28 +1,79 @@
 from loguru import logger
 from typing import TYPE_CHECKING
+from pydantic import BaseModel, Field
+from typing import List, Optional
 
 if TYPE_CHECKING:
     from langflow.graph.vertex.base import Vertex
 
 
+class SourceHandle(BaseModel):
+    baseClasses: List[str] = Field(
+        ..., description="List of base classes for the source handle."
+    )
+    dataType: str = Field(..., description="Data type for the source handle.")
+    id: str = Field(..., description="Unique identifier for the source handle.")
+
+
+class TargetHandle(BaseModel):
+    fieldName: str = Field(..., description="Field name for the target handle.")
+    id: str = Field(..., description="Unique identifier for the target handle.")
+    inputTypes: Optional[List[str]] = Field(
+        None, description="List of input types for the target handle."
+    )
+    type: str = Field(..., description="Type of the target handle.")
+
+
 class Edge:
     def __init__(self, source: "Vertex", target: "Vertex", edge: dict):
         self.source: "Vertex" = source
         self.target: "Vertex" = target
-        self.source_handle = edge.get("sourceHandle", "")
-        self.target_handle = edge.get("targetHandle", "")
-        # 'BaseLoader;BaseOutputParser|documents|PromptTemplate-zmTlD'
-        # target_param is documents
-        self.target_param = self.target_handle.split("|")[1]
-
+        if data := edge.get("data", {}):
+            self._source_handle = data.get("sourceHandle", {})
+            self._target_handle = data.get("targetHandle", {})
+            self.source_handle: SourceHandle = SourceHandle(**self._source_handle)
+            self.target_handle: TargetHandle = TargetHandle(**self._target_handle)
+            self.target_param = self.target_handle.fieldName
+            # validate handles
+            self.validate_handles()
+        else:
+            # Logging here because this is a breaking change
+            logger.error("Edge data is empty")
+            self._source_handle = edge.get("sourceHandle", "")
+            self._target_handle = edge.get("targetHandle", "")
+            # 'BaseLoader;BaseOutputParser|documents|PromptTemplate-zmTlD'
+            # target_param is documents
+            self.target_param = self._target_handle.split("|")[1]
+        # Validate in __init__ to fail fast
         self.validate_edge()
 
+    def validate_handles(self) -> None:
+        if self.target_handle.inputTypes is None:
+            self.valid_handles = (
+                self.target_handle.type in self.source_handle.baseClasses
+            )
+        else:
+            self.valid_handles = (
+                any(
+                    baseClass in self.target_handle.inputTypes
+                    for baseClass in self.source_handle.baseClasses
+                )
+                or self.target_handle.type in self.source_handle.baseClasses
+            )
+        if not self.valid_handles:
+            logger.debug(self.source_handle)
+            logger.debug(self.target_handle)
+            raise ValueError(
+                f"Edge between {self.source.vertex_type} and {self.target.vertex_type} "
+                f"has invalid handles"
+            )
+
     def __setstate__(self, state):
         self.source = state["source"]
         self.target = state["target"]
         self.target_param = state["target_param"]
-        self.source_handle = state["source_handle"]
-        self.target_handle = state["target_handle"]
+        self.source_handle = state.get("source_handle")
+        self.target_handle = state.get("target_handle")
 
     def reset(self) -> None:
         self.source._build_params()

src/backend/langflow/graph/graph/base.py

@@ -2,6 +2,7 @@ from typing import Dict, Generator, List, Type, Union
 
 from langflow.graph.edge.base import Edge
 from langflow.graph.graph.constants import lazy_load_vertex_dict
+from langflow.graph.graph.utils import process_flow
 from langflow.graph.vertex.base import Vertex
 from langflow.graph.vertex.types import (
     FileToolVertex,
@@ -19,11 +20,21 @@ class Graph:
 
     def __init__(
         self,
-        nodes: List[Dict[str, Union[str, Dict[str, Union[str, List[str]]]]]],
+        nodes: List[Dict],
         edges: List[Dict[str, str]],
     ) -> None:
         self._nodes = nodes
         self._edges = edges
+        self.raw_graph_data = {"nodes": nodes, "edges": edges}
+
+        self.top_level_nodes = []
+        for node in self._nodes:
+            if node_id := node.get("id"):
+                self.top_level_nodes.append(node_id)
+
+        self._graph_data = process_flow(self.raw_graph_data)
+        self._nodes = self._graph_data["nodes"]
+        self._edges = self._graph_data["edges"]
         self._build_graph()
 
     def __setstate__(self, state):
@@ -50,6 +61,7 @@ class Graph:
             edges = payload["edges"]
             return cls(nodes, edges)
         except KeyError as exc:
+            logger.exception(exc)
             raise ValueError(
                 f"Invalid payload. Expected keys 'nodes' and 'edges'. Found {list(payload.keys())}"
             ) from exc
@@ -215,7 +227,9 @@ class Graph:
             node_lc_type: str = node_data["node"]["template"]["_type"]  # type: ignore
 
             VertexClass = self._get_vertex_class(node_type, node_lc_type)
-            nodes.append(VertexClass(node))
+            vertex = VertexClass(node)
+            vertex.set_top_level(self.top_level_nodes)
+            nodes.append(vertex)
 
         return nodes