Adds better prompt experience and many other improvements (#621)

.gitignore

@@ -1,3 +1,5 @@
+# This is to avoid Opencommit hook from getting pushed
+prepare-commit-msg
 # Logs
 logs
 *.log
@@ -242,4 +244,5 @@ dmypy.json
 # Poetry
 .testenv/*
 langflow.db
+.githooks/prepare-commit-msg
 langchain.db

Makefile

@@ -5,6 +5,8 @@ all: help
 init:
 	@echo 'Installing pre-commit hooks'
 	git config core.hooksPath .githooks
+	@echo 'Making pre-commit hook executable'
+	chmod +x .githooks/pre-commit
 	@echo 'Installing backend dependencies'
 	make install_backend
 	@echo 'Installing frontend dependencies'

README.md

@@ -31,12 +31,13 @@
 - [Table of Contents](#table-of-contents)
 - [📦 Installation](#-installation)
     - [Locally](#locally)
+    - [HuggingFace Spaces](#huggingface-spaces)
 - [🖥️ Command Line Interface (CLI)](#️-command-line-interface-cli)
     - [Usage](#usage)
     - [Environment Variables](#environment-variables)
 - [Deployment](#deployment)
-    - [Deploy Langflow on Google Cloud Platform](#deploy-langflow-on-google-cloud-platform)
-    - [Deploy Langflow on Jina AI Cloud](#deploy-langflow-on-jina-ai-cloud)
+  - [Deploy Langflow on Google Cloud Platform](#deploy-langflow-on-google-cloud-platform)
+  - [Deploy Langflow on Jina AI Cloud](#deploy-langflow-on-jina-ai-cloud)
       - [API Usage](#api-usage)
 - [🎨 Creating Flows](#-creating-flows)
 - [👋 Contributing](#-contributing)
@@ -61,6 +62,8 @@ or
 langflow # or langflow --help
 ```
 
+### HuggingFace Spaces
+You can also check it out on [HuggingFace Spaces](https://huggingface.co/spaces/Logspace/Langflow) and run it in your browser! You can even clone it and have your own copy of Langflow to play with.
 
 # 🖥️ Command Line Interface (CLI)
 
@@ -103,7 +106,7 @@ A sample `.env` file named `.env.example` is included with the project. Copy thi
 
 # Deployment
 
-### Deploy Langflow on Google Cloud Platform
+## Deploy Langflow on Google Cloud Platform
 
 Follow our step-by-step guide to deploy Langflow on Google Cloud Platform (GCP) using Google Cloud Shell. The guide is available in the [**Langflow in Google Cloud Platform**](GCP_DEPLOYMENT.md) document.
 
@@ -112,7 +115,7 @@ Alternatively, click the **"Open in Cloud Shell"** button below to launch Google
 [![Open in Cloud Shell](https://gstatic.com/cloudssh/images/open-btn.svg)](https://console.cloud.google.com/cloudshell/open?git_repo=https://github.com/logspace-ai/langflow&working_dir=scripts&shellonly=true&tutorial=walkthroughtutorial_spot.md)
 
 
-### Deploy Langflow on [Jina AI Cloud](https://github.com/jina-ai/langchain-serve)
+## Deploy Langflow on [Jina AI Cloud](https://github.com/jina-ai/langchain-serve)
 
 Langflow integrates with langchain-serve to provide a one-command deployment to Jina AI Cloud.
 
@@ -219,6 +222,13 @@ print(run_flow("Your message", flow_id=FLOW_ID, tweaks=TWEAKS))
 
 > Read more about resource customization, cost, and management of Langflow apps on Jina AI Cloud in the **[langchain-serve](https://github.com/jina-ai/langchain-serve)** repository.
 
+## Deploy on Railway
+[![Deploy on Railway](https://railway.app/button.svg)](https://railway.app/template/Emy2sU?referralCode=MnPSdg)
+
+## Deploy on Render
+<a href="https://render.com/deploy?repo=https://github.com/logspace-ai/langflow/tree/main">
+<img src="https://render.com/images/deploy-to-render-button.svg" alt="Deploy to Render" />
+</a>
 
 # 🎨 Creating Flows
 

pyproject.toml

@@ -23,14 +23,14 @@ langflow = "langflow.__main__:main"
 
 [tool.poetry.dependencies]
 python = ">=3.9,<3.11"
-fastapi = "^0.99.0"
+fastapi = "^0.100.0"
 uvicorn = "^0.22.0"
 beautifulsoup4 = "^4.12.2"
 google-search-results = "^2.4.1"
 google-api-python-client = "^2.79.0"
 typer = "^0.9.0"
 gunicorn = "^20.1.0"
-langchain = "^0.0.219"
+langchain = "^0.0.229"
 openai = "^0.27.8"
 pandas = "^2.0.0"
 chromadb = "^0.3.21"
@@ -78,7 +78,7 @@ black = "^23.1.0"
 ipykernel = "^6.21.2"
 mypy = "^1.1.1"
 ruff = "^0.0.254"
-httpx = "^0.23.3"
+httpx = "*"
 pytest = "^7.2.2"
 types-requests = "^2.28.11"
 requests = "^2.28.0"

render.yaml

@@ -0,0 +1,11 @@
+services:
+  # A Docker web service
+  - type: web
+    name: langflow
+    runtime: docker
+    plan: free
+    dockerfilePath: ./Dockerfile
+    repo: https://github.com/logspace-ai/langflow
+    branch: main
+    healthCheckPath: /health
+    autoDeploy: false

src/backend/langflow/api/utils.py

@@ -22,3 +22,38 @@ def remove_api_keys(flow: dict):
                     value["value"] = None
 
     return flow
+
+
+def build_input_keys_response(langchain_object, artifacts):
+    """Build the input keys response."""
+
+    input_keys_response = {
+        "input_keys": {key: "" for key in langchain_object.input_keys},
+        "memory_keys": [],
+        "handle_keys": artifacts.get("handle_keys", []),
+    }
+
+    # Set the input keys values from artifacts
+    for key, value in artifacts.items():
+        if key in input_keys_response["input_keys"]:
+            input_keys_response["input_keys"][key] = value
+    # If the object has memory, that memory will have a memory_variables attribute
+    # memory variables should be removed from the input keys
+    if hasattr(langchain_object, "memory") and hasattr(
+        langchain_object.memory, "memory_variables"
+    ):
+        # Remove memory variables from input keys
+        input_keys_response["input_keys"] = {
+            key: value
+            for key, value in input_keys_response["input_keys"].items()
+            if key not in langchain_object.memory.memory_variables
+        }
+        # Add memory variables to memory_keys
+        input_keys_response["memory_keys"] = langchain_object.memory.memory_variables
+
+    if hasattr(langchain_object, "prompt") and hasattr(
+        langchain_object.prompt, "template"
+    ):
+        input_keys_response["template"] = langchain_object.prompt.template
+
+    return input_keys_response

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

@@ -1,6 +1,8 @@
+from langflow.template.frontend_node.base import FrontendNode
 from pydantic import BaseModel, validator
 
 from langflow.interface.utils import extract_input_variables_from_prompt
+from langchain.prompts import PromptTemplate
 
 
 class CacheResponse(BaseModel):
@@ -11,8 +13,14 @@ class Code(BaseModel):
     code: str
 
 
-class Prompt(BaseModel):
+class FrontendNodeRequest(FrontendNode):
+    template: dict  # type: ignore
+
+
+class ValidatePromptRequest(BaseModel):
+    name: str
     template: str
+    frontend_node: FrontendNodeRequest
 
 
 # Build ValidationResponse class for {"imports": {"errors": []}, "function": {"errors": []}}
@@ -31,6 +39,7 @@ class CodeValidationResponse(BaseModel):
 
 class PromptValidationResponse(BaseModel):
     input_variables: list
+    frontend_node: FrontendNodeRequest
 
 
 INVALID_CHARACTERS = {
@@ -51,34 +60,93 @@ INVALID_CHARACTERS = {
     "}",
 }
 
+INVALID_NAMES = {
+    "input_variables",
+    "output_parser",
+    "partial_variables",
+    "template",
+    "template_format",
+    "validate_template",
+}
+
 
 def validate_prompt(template: str):
     input_variables = extract_input_variables_from_prompt(template)
 
     # Check if there are invalid characters in the input_variables
     input_variables = check_input_variables(input_variables)
+    if any(var in INVALID_NAMES for var in input_variables):
+        raise ValueError(
+            f"Invalid input variables. None of the variables can be named {', '.join(input_variables)}. "
+        )
 
-    return PromptValidationResponse(input_variables=input_variables)
+    try:
+        PromptTemplate(template=template, input_variables=input_variables)
+    except Exception as exc:
+        raise ValueError(str(exc)) from exc
+
+    return input_variables
 
 
 def check_input_variables(input_variables: list):
     invalid_chars = []
     fixed_variables = []
+    wrong_variables = []
+    empty_variables = []
     for variable in input_variables:
         new_var = variable
-        for char in INVALID_CHARACTERS:
-            if char in variable:
-                invalid_chars.append(char)
-                new_var = new_var.replace(char, "")
+
+        # if variable is empty, then we should add that to the wrong variables
+        if not variable:
+            empty_variables.append(variable)
+            continue
+
+        # if variable starts with a number we should add that to the invalid chars
+        # and wrong variables
+        if variable[0].isdigit():
+            invalid_chars.append(variable[0])
+            new_var = new_var.replace(variable[0], "")
+            wrong_variables.append(variable)
+        else:
+            for char in INVALID_CHARACTERS:
+                if char in variable:
+                    invalid_chars.append(char)
+                    new_var = new_var.replace(char, "")
+                    wrong_variables.append(variable)
         fixed_variables.append(new_var)
-        if new_var != variable:
-            input_variables.remove(variable)
-            input_variables.append(new_var)
     # If any of the input_variables is not in the fixed_variables, then it means that
     # there are invalid characters in the input_variables
-    if any(var not in fixed_variables for var in input_variables):
-        raise ValueError(
-            f"Invalid input variables: {input_variables}. Please, use something like {fixed_variables} instead."
-        )
 
+    if any(var not in fixed_variables for var in input_variables):
+        error_message = build_error_message(
+            input_variables,
+            invalid_chars,
+            wrong_variables,
+            fixed_variables,
+            empty_variables,
+        )
+        raise ValueError(error_message)
     return input_variables
+
+
+def build_error_message(
+    input_variables, invalid_chars, wrong_variables, fixed_variables, empty_variables
+):
+    input_variables_str = ", ".join([f"'{var}'" for var in input_variables])
+    error_string = f"Invalid input variables: {input_variables_str}. "
+
+    if wrong_variables and invalid_chars:
+        # fix the wrong variables replacing invalid chars and find them in the fixed variables
+        error_string_vars = "You can fix them by replacing the invalid characters: "
+        wvars = wrong_variables.copy()
+        for i, wrong_var in enumerate(wvars):
+            for char in invalid_chars:
+                wrong_var = wrong_var.replace(char, "")
+            if wrong_var in fixed_variables:
+                error_string_vars += f"'{wrong_variables[i]}' -> '{wrong_var}'"
+        error_string += error_string_vars
+    elif empty_variables:
+        error_string += f" There are {len(empty_variables)} empty variable{'s' if len(empty_variables) > 1 else ''}."
+    elif len(set(fixed_variables)) != len(fixed_variables):
+        error_string += "There are duplicate variables."
+    return error_string

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

@@ -1,22 +1,132 @@
 import asyncio
-from typing import Any
 
 from langchain.callbacks.base import AsyncCallbackHandler, BaseCallbackHandler
 
 from langflow.api.v1.schemas import ChatResponse
 
 
+from typing import Any, Dict, List, Union
+from fastapi import WebSocket
+
+
+from langchain.schema import AgentAction, LLMResult, AgentFinish
+from langflow.utils.logger import logger
+
+
 # https://github.com/hwchase17/chat-langchain/blob/master/callback.py
 class AsyncStreamingLLMCallbackHandler(AsyncCallbackHandler):
     """Callback handler for streaming LLM responses."""
 
-    def __init__(self, websocket):
+    def __init__(self, websocket: WebSocket):
         self.websocket = websocket
 
     async def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
         resp = ChatResponse(message=token, type="stream", intermediate_steps="")
         await self.websocket.send_json(resp.dict())
 
+    async def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> Any:
+        """Run when LLM starts running."""
+
+    async def on_llm_end(self, response: LLMResult, **kwargs: Any) -> Any:
+        """Run when LLM ends running."""
+
+    async def on_llm_error(
+        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
+    ) -> Any:
+        """Run when LLM errors."""
+
+    async def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> Any:
+        """Run when chain starts running."""
+
+    async def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> Any:
+        """Run when chain ends running."""
+
+    async def on_chain_error(
+        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
+    ) -> Any:
+        """Run when chain errors."""
+
+    async def on_tool_start(
+        self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
+    ) -> Any:
+        """Run when tool starts running."""
+        resp = ChatResponse(
+            message="",
+            type="stream",
+            intermediate_steps=f"Tool input: {input_str}",
+        )
+        await self.websocket.send_json(resp.dict())
+
+    async def on_tool_end(self, output: str, **kwargs: Any) -> Any:
+        """Run when tool ends running."""
+        observation_prefix = kwargs.get("observation_prefix", "Tool output: ")
+        split_output = output.split()
+        first_word = split_output[0]
+        rest_of_output = split_output[1:]
+        # Create a formatted message.
+        intermediate_steps = f"{observation_prefix}{first_word}"
+
+        # Create a ChatResponse instance.
+        resp = ChatResponse(
+            message="",
+            type="stream",
+            intermediate_steps=intermediate_steps,
+        )
+        rest_of_resps = [
+            ChatResponse(
+                message="",
+                type="stream",
+                intermediate_steps=f"{word}",
+            )
+            for word in rest_of_output
+        ]
+        resps = [resp] + rest_of_resps
+        # Try to send the response, handle potential errors.
+
+        try:
+            # This is to emulate the stream of tokens
+            for resp in resps:
+                await self.websocket.send_json(resp.dict())
+        except Exception as e:
+            logger.error(e)
+
+    async def on_tool_error(
+        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
+    ) -> Any:
+        """Run when tool errors."""
+
+    async def on_text(self, text: str, **kwargs: Any) -> Any:
+        """Run on arbitrary text."""
+        # This runs when first sending the prompt
+        # to the LLM, adding it will send the final prompt
+        # to the frontend
+
+    async def on_agent_action(self, action: AgentAction, **kwargs: Any):
+        log = f"Thought: {action.log}"
+        # if there are line breaks, split them and send them
+        # as separate messages
+        if "\n" in log:
+            logs = log.split("\n")
+            for log in logs:
+                resp = ChatResponse(message="", type="stream", intermediate_steps=log)
+                await self.websocket.send_json(resp.dict())
+        else:
+            resp = ChatResponse(message="", type="stream", intermediate_steps=log)
+            await self.websocket.send_json(resp.dict())
+
+    async def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> Any:
+        """Run on agent end."""
+        resp = ChatResponse(
+            message="",
+            type="stream",
+            intermediate_steps=finish.log,
+        )
+        await self.websocket.send_json(resp.dict())
+
 
 class StreamingLLMCallbackHandler(BaseCallbackHandler):
     """Callback handler for streaming LLM responses."""

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

@@ -1,5 +1,6 @@
 from fastapi import APIRouter, HTTPException, WebSocket, WebSocketException, status
 from fastapi.responses import StreamingResponse
+from langflow.api.utils import build_input_keys_response
 from langflow.api.v1.schemas import BuildStatus, BuiltResponse, InitResponse, StreamData
 
 from langflow.chat.manager import ChatManager
@@ -83,6 +84,7 @@ async def stream_build(flow_id: str):
 
     async def event_stream(flow_id):
         final_response = {"end_of_stream": True}
+        artifacts = {}
         try:
             if flow_id not in flow_data_store:
                 error_message = "Invalid session ID"
@@ -113,13 +115,6 @@ async def stream_build(flow_id: str):
 
             number_of_nodes = len(graph.nodes)
             flow_data_store[flow_id]["status"] = BuildStatus.IN_PROGRESS
-            # To deal with the ZeroShotAgent case
-            # we need to build the root node first
-            # and then the rest of the graph
-            # This is a big problem because certain nodes require
-            # params that are not connected to it.
-            # We should consider connecting the tools to the ZeroShotPrompt
-            graph.build()
 
             for i, vertex in enumerate(graph.generator_build(), 1):
                 try:
@@ -131,8 +126,13 @@ async def stream_build(flow_id: str):
                     params = vertex._built_object_repr()
                     valid = True
                     logger.debug(
-                        f"Building node {params[:50]}{'...' if len(params) > 50 else ''}"
+                        f"Building node {str(params)[:50]}{'...' if len(str(params)) > 50 else ''}"
                     )
+                    if vertex.artifacts:
+                        # The artifacts will be prompt variables
+                        # passed to build_input_keys_response
+                        # to set the input_keys values
+                        artifacts.update(vertex.artifacts)
                 except Exception as exc:
                     params = str(exc)
                     valid = False
@@ -147,9 +147,26 @@ async def stream_build(flow_id: str):
 
                 yield str(StreamData(event="message", data=response))
 
-            chat_manager.set_cache(flow_id, graph.build())
+            langchain_object = graph.build()
+            # Now we  need to check the input_keys to send them to the client
+            if hasattr(langchain_object, "input_keys"):
+                input_keys_response = build_input_keys_response(
+                    langchain_object, artifacts
+                )
+            else:
+                input_keys_response = {
+                    "input_keys": {},
+                    "memory_keys": [],
+                    "handle_keys": [],
+                }
+            yield str(StreamData(event="message", data=input_keys_response))
+
+            chat_manager.set_cache(flow_id, langchain_object)
+            # We need to reset the chat history
+            chat_manager.chat_history.empty_history(flow_id)
             flow_data_store[flow_id]["status"] = BuildStatus.SUCCESS
         except Exception as exc:
+            logger.exception(exc)
             logger.error("Error while building the flow: %s", exc)
             flow_data_store[flow_id]["status"] = BuildStatus.FAILURE
             yield str(StreamData(event="error", data={"error": str(exc)}))

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

@@ -53,7 +53,7 @@ class ChatMessage(BaseModel):
     """Chat message schema."""
 
     is_bot: bool = False
-    message: Union[str, None] = None
+    message: Union[str, None, dict] = None
     type: str = "human"
 
 

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

@@ -3,10 +3,11 @@ from fastapi import APIRouter, HTTPException
 from langflow.api.v1.base import (
     Code,
     CodeValidationResponse,
-    Prompt,
+    ValidatePromptRequest,
     PromptValidationResponse,
     validate_prompt,
 )
+from langflow.template.field.base import TemplateField
 from langflow.utils.logger import logger
 from langflow.utils.validate import validate_code
 
@@ -27,9 +28,100 @@ def post_validate_code(code: Code):
 
 
 @router.post("/prompt", status_code=200, response_model=PromptValidationResponse)
-def post_validate_prompt(prompt: Prompt):
+def post_validate_prompt(prompt_request: ValidatePromptRequest):
     try:
-        return validate_prompt(prompt.template)
+        input_variables = validate_prompt(prompt_request.template)
+
+        old_custom_fields = get_old_custom_fields(prompt_request)
+
+        add_new_variables_to_template(input_variables, prompt_request)
+
+        remove_old_variables_from_template(
+            old_custom_fields, input_variables, prompt_request
+        )
+
+        update_input_variables_field(input_variables, prompt_request)
+
+        return PromptValidationResponse(
+            input_variables=input_variables,
+            frontend_node=prompt_request.frontend_node,
+        )
     except Exception as e:
         logger.exception(e)
         raise HTTPException(status_code=500, detail=str(e)) from e
+
+
+def get_old_custom_fields(prompt_request):
+    try:
+        old_custom_fields = prompt_request.frontend_node.custom_fields[
+            prompt_request.name
+        ].copy()
+    except KeyError:
+        old_custom_fields = []
+    prompt_request.frontend_node.custom_fields[prompt_request.name] = []
+    return old_custom_fields
+
+
+def add_new_variables_to_template(input_variables, prompt_request):
+    for variable in input_variables:
+        try:
+            template_field = TemplateField(
+                name=variable,
+                display_name=variable,
+                field_type="str",
+                show=True,
+                advanced=False,
+                multiline=True,
+                input_types=["Document", "BaseOutputParser"],
+                value="",  # Set the value to empty string
+            )
+            if variable in prompt_request.frontend_node.template:
+                # Set the new field with the old value
+                template_field.value = prompt_request.frontend_node.template[variable][
+                    "value"
+                ]
+
+            prompt_request.frontend_node.template[variable] = template_field.to_dict()
+
+            # Check if variable is not already in the list before appending
+            if (
+                variable
+                not in prompt_request.frontend_node.custom_fields[prompt_request.name]
+            ):
+                prompt_request.frontend_node.custom_fields[prompt_request.name].append(
+                    variable
+                )
+
+        except Exception as exc:
+            logger.exception(exc)
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+
+def remove_old_variables_from_template(
+    old_custom_fields, input_variables, prompt_request
+):
+    for variable in old_custom_fields:
+        if variable not in input_variables:
+            try:
+                # Remove the variable from custom_fields associated with the given name
+                if (
+                    variable
+                    in prompt_request.frontend_node.custom_fields[prompt_request.name]
+                ):
+                    prompt_request.frontend_node.custom_fields[
+                        prompt_request.name
+                    ].remove(variable)
+
+                # Remove the variable from the template
+                prompt_request.frontend_node.template.pop(variable, None)
+
+            except Exception as exc:
+                logger.exception(exc)
+                raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+
+def update_input_variables_field(input_variables, prompt_request):
+    if "input_variables" in prompt_request.frontend_node.template:
+        prompt_request.frontend_node.template["input_variables"][
+            "value"
+        ] = input_variables

src/backend/langflow/chat/manager.py

@@ -104,16 +104,22 @@ class ChatManager:
 
     async def close_connection(self, client_id: str, code: int, reason: str):
         if websocket := self.active_connections[client_id]:
-            await websocket.close(code=code, reason=reason)
-            self.disconnect(client_id)
+            try:
+                await websocket.close(code=code, reason=reason)
+                self.disconnect(client_id)
+            except RuntimeError as exc:
+                # This is to catch the following error:
+                #  Unexpected ASGI message 'websocket.close', after sending 'websocket.close'
+                if "after sending" in str(exc):
+                    logger.error(exc)
 
     async def process_message(
         self, client_id: str, payload: Dict, langchain_object: Any
     ):
         # Process the graph data and chat message
-        chat_message = payload.pop("message", "")
-        chat_message = ChatMessage(message=chat_message)
-        self.chat_history.add_message(client_id, chat_message)
+        chat_inputs = payload.pop("inputs", "")
+        chat_inputs = ChatMessage(message=chat_inputs)
+        self.chat_history.add_message(client_id, chat_inputs)
 
         # graph_data = payload
         start_resp = ChatResponse(message=None, type="start", intermediate_steps="")
@@ -126,7 +132,7 @@ class ChatManager:
 
             result, intermediate_steps = await process_graph(
                 langchain_object=langchain_object,
-                chat_message=chat_message,
+                chat_inputs=chat_inputs,
                 websocket=self.active_connections[client_id],
             )
         except Exception as e:

src/backend/langflow/chat/utils.py

@@ -7,7 +7,7 @@ from langflow.utils.logger import logger
 
 async def process_graph(
     langchain_object,
-    chat_message: ChatMessage,
+    chat_inputs: ChatMessage,
     websocket: WebSocket,
 ):
     langchain_object = try_setting_streaming_options(langchain_object, websocket)
@@ -21,9 +21,13 @@ async def process_graph(
 
     # Generate result and thought
     try:
+        if not chat_inputs.message:
+            logger.debug("No message provided")
+            raise ValueError("No message provided")
+
         logger.debug("Generating result and thought")
         result, intermediate_steps = await get_result_and_steps(
-            langchain_object, chat_message.message or "", websocket=websocket
+            langchain_object, chat_inputs.message, websocket=websocket
         )
         logger.debug("Generated result and intermediate_steps")
         return result, intermediate_steps

src/backend/langflow/config.yaml

@@ -151,12 +151,19 @@ memories:
     documentation: "https://python.langchain.com/docs/modules/memory/how_to/buffer_window"
   VectorStoreRetrieverMemory:
     documentation: "https://python.langchain.com/docs/modules/memory/how_to/vectorstore_retriever_memory"
-
+  MongoDBChatMessageHistory:
+    documentation: "https://python.langchain.com/docs/modules/memory/integrations/mongodb_chat_message_history"
 prompts:
+  ChatMessagePromptTemplate:
+    documentation: "https://python.langchain.com/docs/modules/model_io/prompts/prompt_templates/msg_prompt_templates"
+  HumanMessagePromptTemplate:
+    documentation: "https://python.langchain.com/docs/modules/model_io/models/chat/how_to/prompts"
+  SystemMessagePromptTemplate:
+    documentation: "https://python.langchain.com/docs/modules/model_io/models/chat/how_to/prompts"
+  ChatPromptTemplate:
+    documentation: "https://python.langchain.com/docs/modules/model_io/models/chat/how_to/prompts"
   PromptTemplate:
     documentation: "https://python.langchain.com/docs/modules/model_io/prompts/prompt_templates/"
-  ZeroShotPrompt:
-    documentation: "https://python.langchain.com/docs/modules/agents/how_to/custom_mrkl_agent"
 textsplitters:
   CharacterTextSplitter:
     documentation: "https://python.langchain.com/docs/modules/data_connection/document_transformers/text_splitters/character_text_splitter"
@@ -269,7 +276,17 @@ vectorstores:
   SupabaseVectorStore:
     documentation: "https://python.langchain.com/docs/modules/data_connection/vectorstores/integrations/supabase"
   MongoDBAtlasVectorSearch:
-    documentation: "https://python.langchain.com/docs/modules/data_connection/vectorstores/integrations/mongodb_atlas_vector_search"
+    documentation: "https://python.langchain.com/docs/modules/data_connection/vectorstores/integrations/mongodb_atlas"
+  # Requires docarray >=0.32.0 but langchain-serve requires jina 3.15.2 which doesn't support docarray >=0.32.0
+  # DocArrayInMemorySearch:
+  #   documentation: "https://python.langchain.com/docs/modules/data_connection/vectorstores/integrations/docarray_in_memory"
 wrappers:
   RequestsWrapper:
     documentation: ""
+  SQLDatabase:
+    documentation: ""
+output_parsers:
+  StructuredOutputParser:
+    documentation: "https://python.langchain.com/docs/modules/model_io/output_parsers/structured"
+  ResponseSchema:
+    documentation: "https://python.langchain.com/docs/modules/model_io/output_parsers/structured"

src/backend/langflow/custom/customs.py

@@ -2,9 +2,9 @@ from langflow.template import frontend_node
 
 # These should always be instantiated
 CUSTOM_NODES = {
-    "prompts": {
-        "ZeroShotPrompt": frontend_node.prompts.ZeroShotPromptNode(),
-    },
+    # "prompts": {
+    #     "ZeroShotPrompt": frontend_node.prompts.ZeroShotPromptNode(),
+    # },
     "tools": {
         "PythonFunctionTool": frontend_node.tools.PythonFunctionToolNode(),
         "PythonFunction": frontend_node.tools.PythonFunctionNode(),
@@ -23,6 +23,7 @@ CUSTOM_NODES = {
     },
     "memories": {
         "PostgresChatMessageHistory": frontend_node.memories.PostgresChatMessageHistoryFrontendNode(),
+        "MongoDBChatMessageHistory": frontend_node.memories.MongoDBChatMessageHistoryFrontendNode(),
     },
     "chains": {
         "SeriesCharacterChain": frontend_node.chains.SeriesCharacterChainNode(),

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

@@ -6,9 +6,15 @@ if TYPE_CHECKING:
 
 
 class Edge:
-    def __init__(self, source: "Vertex", target: "Vertex"):
+    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]
+
         self.validate_edge()
 
     def validate_edge(self) -> None:
@@ -42,6 +48,16 @@ class Edge:
 
     def __repr__(self) -> str:
         return (
-            f"Edge(source={self.source.id}, target={self.target.id}, valid={self.valid}"
+            f"Edge(source={self.source.id}, target={self.target.id}, target_param={self.target_param}"
             f", matched_type={self.matched_type})"
         )
+
+    def __hash__(self) -> int:
+        return hash(self.__repr__())
+
+    def __eq__(self, __value: object) -> bool:
+        return (
+            self.__repr__() == __value.__repr__()
+            if isinstance(__value, Edge)
+            else False
+        )

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

@@ -179,7 +179,7 @@ class Graph:
                 raise ValueError(f"Source node {edge['source']} not found")
             if target is None:
                 raise ValueError(f"Target node {edge['target']} not found")
-            edges.append(Edge(source, target))
+            edges.append(Edge(source, target, edge))
         return edges
 
     def _get_vertex_class(self, node_type: str, node_lc_type: str) -> Type[Vertex]:
@@ -214,3 +214,10 @@ class Graph:
         if node_type in node_types:
             children.append(node)
         return children
+
+    def __repr__(self):
+        node_ids = [node.id for node in self.nodes]
+        edges_repr = "\n".join(
+            [f"{edge.source.id} --> {edge.target.id}" for edge in self.edges]
+        )
+        return f"Graph:\nNodes: {node_ids}\nConnections:\n{edges_repr}"

src/backend/langflow/graph/graph/constants.py

@@ -12,6 +12,7 @@ from langflow.interface.toolkits.base import toolkits_creator
 from langflow.interface.tools.base import tool_creator
 from langflow.interface.vector_store.base import vectorstore_creator
 from langflow.interface.wrappers.base import wrapper_creator
+from langflow.interface.output_parsers.base import output_parser_creator
 from langflow.interface.retrievers.base import retriever_creator
 
 from typing import Dict, Type
@@ -30,5 +31,6 @@ VERTEX_TYPE_MAP: Dict[str, Type[Vertex]] = {
     **{t: types.VectorStoreVertex for t in vectorstore_creator.to_list()},
     **{t: types.DocumentLoaderVertex for t in documentloader_creator.to_list()},
     **{t: types.TextSplitterVertex for t in textsplitter_creator.to_list()},
+    **{t: types.OutputParserVertex for t in output_parser_creator.to_list()},
     **{t: types.RetrieverVertex for t in retriever_creator.to_list()},
 }