✨ feat(base.py): add support for ZepRetriever in from_method_nodes dictionary
The build_template_from_method call for the MultiQueryRetriever in the get_signature method was using the incorrect method name "from_llm". It has been fixed to use the correct method name "from_method_nodes". Additionally, support for the ZepRetriever has been added to the from_method_nodes dictionary to allow for its usage in the RetrieverCreator class.
The 'url' field in the MemoryFrontendNode class is now set to be shown in the frontend. This change allows the 'url' field to be visible and accessible to users in the frontend interface.
The "self" parameter is now excluded from the template building process. This change improves the accuracy of the generated template by removing unnecessary information.
The unused integrations in the memories and retrievers sections have been commented out to improve code readability and remove unnecessary clutter. These integrations are not currently being used in the application and can be safely ignored.
The instantiate_memory function now includes error handling for a specific AttributeError that occurs when the object does not have a 'cursor' attribute. If this error occurs, an AttributeError is raised with a specific error message indicating a failure to build a connection to the database. This change improves the error handling and provides more informative error messages for debugging purposes.
🐛 fix(base.py): call the method to remove unwanted base classes before converting the frontend node to a dict
The `process_base_classes` method is added to the `FrontendNode` class to remove unwanted base classes from the list of base classes. This method iterates over the base classes and filters out any classes that are present in the `CLASSES_TO_REMOVE` list. The method is then called before converting the frontend node to a dictionary representation in the `to_dict` method to ensure that the unwanted base classes are not included in the final output.
The `add_extra_base_classes` method is added to the `LLMFrontendNode` class. This method checks if the "BaseLLM" class is already present in the `base_classes` list and appends it if not. This change allows for easier extensibility by providing a way to add additional base classes to the `LLMFrontendNode` class.
The `from_method_nodes` dictionary is added to the `RetrieverCreator` class in order to map the "MultiQueryRetriever" node to the "from_llm" method. This refactor improves the readability and maintainability of the code by explicitly defining the mapping between nodes and methods.
🚀 feat(loading.py): implement the ability to instantiate retrievers based on node type and class object
The `instantiate_based_on_type` function now includes a new condition to handle the instantiation of retrievers. The `instantiate_retriever` function is introduced to handle the specific logic for creating retrievers. This change allows for the dynamic creation of retrievers based on the provided node type and class object.
✨ feat(utils.py): add support for importing retriever module based on retriever name
The `import_retriever` function is added to the `utils.py` module to allow importing the retriever module based on the retriever name. This function uses the `import_module` function from the `importlib` module to dynamically import the retriever module from the `langchain.retrievers` package. This enhances the modularity and extensibility of the codebase by providing a convenient way to import retrievers based on their names.
The RetrieverVertex class is added to the list of available vertex types in the langflow.graph.vertex.types module. This allows for the creation of vertices that represent retrievers in the graph.
The import statements for vertex types in the constants.py file have been refactored to import from langflow.graph.vertex.types as types. This change improves the readability and maintainability of the code by making it clear where the vertex types are coming from.
🐛 fix(chat.py): fix incorrect key used to retrieve graph_data from flow_data_store
The BuildStatus.IN_PROGRESS constant is changed to BuildStatus.STARTED to provide a more accurate representation of the flow status. Additionally, the incorrect key "data" is replaced with "graph_data" when retrieving the graph data from the flow_data_store dictionary.
🐛 fix(util.py): handle non-string types in format_dict function
The base retriever class is added to provide a common interface for all retrievers in the language chain. The frontend node class for retrievers is also added to handle the formatting of fields specific to retrievers.
In the util.py file, a fix is made to handle non-string types in the format_dict function. Previously, if the type of a field was not a string, an error would occur. This fix ensures that the type is converted to a string before further processing.
The __init__.py file is added to the retrievers directory to make it a Python package. This allows the directory to be recognized as a module and enables importing of modules and submodules within the retrievers directory.
The type dictionary in the listing.py file now includes a "retrievers" key, which contains a list of retriever creators. This allows for the inclusion of retrievers as a supported type in the application.
🔀 refactor(types.py): add langchain_types_dict as a separate variable to improve code readability and maintainability
The import statement in `endpoints.py` has been updated to import `langchain_types_dict` instead of `build_langchain_types_dict` for consistency with the variable name. This change improves code readability and maintainability.
In `types.py`, a new variable `langchain_types_dict` has been added as a separate variable to store the result of `build_langchain_types_dict()`. This change improves code readability and makes it easier to understand the purpose of the variable.
🔧 chore(settings.py): add retrievers attribute to Settings class
The config.yaml file now includes a documentation link for the MultiQueryRetriever in the retrievers section. This link provides additional information on how to use the MultiQueryRetriever. In the settings.py file, the Settings class now includes a retrievers attribute to store retriever-related settings. This allows for easier management and configuration of retrievers in the application.
💡 refactor(base.py): The field formatting logic in the FrontendNode class has been refactored into a separate class called FieldFormatters. This improves code organization and separation of concerns, making it easier to maintain and extend the field formatting functionality in the future.
The trailing whitespace has been removed for consistency and readability. The unused import of `DEFAULT_CONNECTION_STRING` from `langchain.memory.chat_message_histories.postgres` has been removed. The `PostgresChatMessageHistoryFrontendNode` now has a default value for the `connection_string` field, which is set to `DEFAULT_CONNECTION_STRING`. This ensures that the field has a default value when creating instances of the class.
🔧 chore(memories.py): remove trailing whitespace and unused import
🔧 refactor(field_formatters.py): refactor field formatters for template frontend_node
The commit adds a new file `field_formatters.py` to the `frontend_node/formatter` directory in the `langflow/template` backend. This file contains multiple field formatters for the template frontend_node. The formatters handle various formatting tasks such as formatting field names, setting field options, handling special fields, and formatting field types. The commit aims to improve the code organization and maintainability by separating the field formatting logic into dedicated formatters.
The base.py file is a new addition to the project. It introduces the FieldFormatter class, which is an abstract base class (ABC) for formatting template fields. This class provides a format() method that takes a TemplateField object as input and is meant to be implemented by subclasses. This addition allows for the creation of custom field formatters in the project.
The "RetrievalQA" memory field in the template frontend node is updated to have the "show" and "required" properties set to False. This change is made to hide the memory field and make it optional. Additionally, the "advanced" property is set to False for all fields, and the "password" property is set to False for fields containing the word "key" in their name.
The unnecessary imports have been removed from the chat.py file to improve code cleanliness and readability. The init_build endpoint in the chat.py file has been updated to include the flow_id as a path parameter instead of extracting it from the graph_data dictionary. This change allows for a more explicit and consistent API design.
🔧 chore(chat.py): remove unnecessary imports and reformat code for better readability
The import statement for the BuildStatus enum in the schemas module has been updated to ensure the correct import. Additionally, a new "status" field has been added to the flow_data_store dictionary to track the build status of flows. The status is set to BuildStatus.IN_PROGRESS when a flow is being built, BuildStatus.SUCCESS when the build is successful, and BuildStatus.FAILURE when there is an error during the build process. This allows for better tracking and management of flow builds.
🐛 fix(chat.py): change import statement for BuildStatus in schemas module
The BuildStatus enum is added to represent the different statuses that a build can have: SUCCESS, FAILURE, and IN_PROGRESS. This enum will be used to provide a more structured and consistent way of handling build statuses in the application.
The `instantiate_textsplitter` function has been refactored to improve readability and remove unnecessary code. The condition for creating the `text_splitter` object has been simplified and the `separator_type` parameter is now removed from the `params` dictionary if it exists. Additionally, the `language` parameter is now passed as an instance of the `Language` class from the `langchain.text_splitter` module. This change ensures that the `text_splitter` object is created correctly and the `split_documents` method is called with the appropriate parameters.
The options list for the separator_type field in the TextSplittersFrontendNode class has been extracted into a variable called options. This improves code readability and allows for easier modification and sorting of the options list.
The documentation link for ConversationBufferMemory in the memories section has been updated to point to the correct URL "https://python.langchain.com/docs/modules/memory/how_to/buffer". This change ensures that users can access the correct documentation for using ConversationBufferMemory.
🐛 fix(loading.py): handle case where separator_type is not provided in params
The first fix ensures that if the metadata is an empty dict, it will not be added to the documents if they already have metadata. This prevents overwriting existing metadata.
The second fix handles the case where the separator_type is not provided in the params. In this case, the text_splitter will be instantiated using the class_object and the params as is.
🔥 refactor(manager.py): remove unnecessary blank line at the end of the file
The package version has been updated to 0.2.3 in the pyproject.toml file. This is a chore as it does not affect the functionality of the package. The blank line at the end of the manager.py file has been removed as it is unnecessary and does not add any value to the code. This is a refactor as it improves the code readability.
The variable name static_files_dir was changed to improve semantics. It is now more clear that it is a directory path. An optional static_files_dir parameter was added to the setup_app function to allow for a directory path to be passed in. This allows for more flexibility in serving static files.
🐛 fix(__main__.py): fix static_files_dir variable name to improve semantics
The first change removes an extra blank line in the ChatManager class. The second change updates the try_setting_streaming_options function to use the ChatConfig class to set the streaming option instead of hardcoding it. This makes the code more modular and easier to maintain.
This commit adds a new function `instantiate_llm` to handle LLM (Language Model) instantiation. It also sets the `ChatConfig.streaming` attribute based on the `openai_api_base` parameter. This is a workaround to ensure that JinaChat works until streaming is implemented.
The ChatConfig class is added to the project with a single attribute, streaming, set to True. This attribute is used to determine whether the chatbot should use streaming or request-response communication with the client.
✨ feat(__main__.py, main.py): add support for a custom static files directory to be passed as an argument to the app
The `setup_static_files` function has been moved from `__main__.py` to `main.py` to improve code organization. The function has also been renamed to `setup_app` to better reflect its purpose. The `create_app` function has been renamed to `setup_app` to follow the naming convention of the new function. The `setup_app` function now accepts an optional argument `static_files_dir` which allows the user to specify a custom directory for static files. This improves the flexibility of the app as it can now be run with a custom frontend.
This commit updates the documentation in the constants.py file to include additional API options that can be used instead of the default OpenAI API. The new options are JinaChat, LocalAI, and Prem. This change provides more information to the user and allows them to make an informed decision when choosing an API to use.
The `info` field is added to the `TemplateField` class to provide additional information about the field. The `OPENAI_API_BASE_INFO` constant is added to the `constants.py` file to provide information about the base URL of the OpenAI API and how it can be changed to use other APIs like Prem and LocalAI. The `info` field is set to `OPENAI_API_BASE_INFO` for the `openai_api_base` field in the `LLMFrontendNode` class in `llms.py`.
