version to 0.6.1 (#3253)

Signed-off-by: Jat <jat@sinosky.org>

.github/workflows/build-push.yml

@@ -46,7 +46,7 @@ jobs:
         with:
           images: ${{ env[matrix.image_name_env] }}
           tags: |
-            type=raw,value=latest,enable=${{ github.ref == 'refs/heads/main' && startsWith(github.ref, 'refs/tags/') }}
+            type=raw,value=latest,enable=${{ startsWith(github.ref, 'refs/tags/') }}
             type=ref,event=branch
             type=sha,enable=true,priority=100,prefix=,suffix=,format=long
             type=raw,value=${{ github.ref_name }},enable=${{ startsWith(github.ref, 'refs/tags/') }}

CONTRIBUTING.md

@@ -36,7 +36,7 @@ In terms of licensing, please take a minute to read our short [License and Contr
   | Feature Type                                                 | Priority        |
   | ------------------------------------------------------------ | --------------- |
   | High-Priority Features as being labeled by a team member     | High Priority   |
-  | Popular feature requests from our [community feedback board](https://feedback.dify.ai/) | Medium Priority |
+  | Popular feature requests from our [community feedback board](https://github.com/langgenius/dify/discussions/categories/feedbacks) | Medium Priority |
   | Non-core features and minor enhancements                     | Low Priority    |
   | Valuable but not immediate                                   | Future-Feature  |
 

CONTRIBUTING_CN.md

@@ -34,7 +34,7 @@
   | Feature Type                                                 | Priority        |
   | ------------------------------------------------------------ | --------------- |
   | High-Priority Features as being labeled by a team member     | High Priority   |
-  | Popular feature requests from our [community feedback board](https://feedback.dify.ai/) | Medium Priority |
+  | Popular feature requests from our [community feedback board](https://github.com/langgenius/dify/discussions/categories/feedbacks) | Medium Priority |
   | Non-core features and minor enhancements                     | Low Priority    |
   | Valuable but not immediate                                   | Future-Feature  |
 

README.md

@@ -29,16 +29,35 @@
 
 **Dify** is an open-source LLM app development platform. Dify's intuitive interface combines a RAG pipeline, AI workflow orchestration, agent capabilities, model management, observability features and more, letting you quickly go from prototype to production.
 
-![](./images/demo.png)
+https://github.com/langgenius/dify/assets/13230914/979e7a68-f067-4bbc-b38e-2deb2cc2bbb5
 
 
+## Using Dify Cloud
 
-## Using our Cloud Services
+You can try out [Dify Cloud](https://dify.ai) now. It provides all the capabilities of the self-deployed version, and includes 200 free GPT-4 calls.
 
-You can try out [Dify.AI Cloud](https://dify.ai) now. It provides all the capabilities of the self-deployed version, and includes 200 free requests to OpenAI GPT-3.5.
+## Dify for Enterprise / Organizations
+
+[Schedule a meeting with us](#Direct-Meetings) or [send us an email](mailto:business@dify.ai?subject=[GitHub]Business%20License%20Inquiry) to discuss enterprise needs. 
+
+For startups and small businesses using AWS, check out [Dify Premium on AWS Marketplace](https://aws.amazon.com/marketplace/pp/prodview-t22mebxzwjhu6) and deploy it to your own AWS VPC with one-click. It's an affordable AMI offering with the option to create apps with custom logo and branding.
+
+## Features
+
+![](./images/models.png)
+
+**1. Workflow**: Create and test complex AI workflows on a visual canvas, with pre-built nodes taking advantage of the power of all the following features and beyond.
+
+**2. Extensive LLM support**: Seamless integration with hundreds of proprietary / open-source LLMs and dozens of inference providers, including GPT, Mistral, Llama2, and OpenAI API-compatible models. A full list of supported model providers is kept [here](https://docs.dify.ai/getting-started/readme/model-providers).
+
+**3. Prompt IDE**: Visual orchestration of applications and services based on any LLMs. Easily share with your team.
+
+**4. RAG Engine**: Includes various RAG capabilities based on full-text indexing or vector database embeddings, allowing direct upload of PDFs, TXTs, and other text formats.
+
+**5. AI Agent**: Based on Function Calling and ReAct, the Agent inference framework allows users to customize tools, what you see is what you get. Dify provides more than a dozen built-in tools for AI agents, such as Google Search, DELL·E, Stable Diffusion, WolframAlpha, etc.
+
+**6. LLMOps**: Monitor and analyze application logs and performance, continuously improving Prompts, datasets, or models based on production data.
 
-### Looking to purchase via AWS?
-Check out [Dify Premium on AWS](https://aws.amazon.com/marketplace/pp/prodview-t22mebxzwjhu6) and deploy it to your own AWS VPC with one-click. 
 
 ## Dify vs. LangChain vs. Assistants API
 
@@ -52,28 +71,10 @@ Check out [Dify Premium on AWS](https://aws.amazon.com/marketplace/pp/prodview-t
 | **Local Deployment** | Supported | Not Supported | Not Applicable |
 
 
-
-## Features
-
-![](./images/models.png)
-
-**1. LLM Support**: Integration with OpenAI's GPT family of models, or the open-source Llama2 family models. In fact, Dify supports mainstream commercial models and open-source models (locally deployed or based on MaaS).
-
-**2. Prompt IDE**: Visual orchestration of applications and services based on LLMs with your team.
-
-**3. RAG Engine**: Includes various RAG capabilities based on full-text indexing or vector database embeddings, allowing direct upload of PDFs, TXTs, and other text formats.
-
-**4. AI Agent**: Based on Function Calling and ReAct, the Agent inference framework allows users to customize tools, what you see is what you get. Dify provides more than a dozen built-in tool calling capabilities, such as Google Search, DELL·E, Stable Diffusion, WolframAlpha, etc.
-
-
-**5. Continuous Operations**: Monitor and analyze application logs and performance, continuously improving Prompts, datasets, or models using production data.
-
 ## Before You Start
 
 **Star us on GitHub, and be instantly notified for new releases!**
-
 ![star-us](https://github.com/langgenius/dify/assets/100913391/95f37259-7370-4456-a9f0-0bc01ef8642f)
-
 - [Website](https://dify.ai)
 - [Docs](https://docs.dify.ai)
 - [Deployment Docs](https://docs.dify.ai/getting-started/install-self-hosted)
@@ -138,21 +139,18 @@ We are looking for contributors to help with translating Dify to languages other
 
 ## Community & Support
 
-* [Github Discussion](https://github.com/langgenius/dify/discussions). Best for: sharing feedback and checking out our feature roadmap.
+* [Github Discussion](https://github.com/langgenius/dify/discussions). Best for: sharing feedback and asking questions.
 * [GitHub Issues](https://github.com/langgenius/dify/issues). Best for: bugs you encounter using Dify.AI, and feature proposals. See our [Contribution Guide](https://github.com/langgenius/dify/blob/main/CONTRIBUTING.md).
 * [Email Support](mailto:hello@dify.ai?subject=[GitHub]Questions%20About%20Dify). Best for: questions you have about using Dify.AI.
 * [Discord](https://discord.gg/FngNHpbcY7). Best for: sharing your applications and hanging out with the community.
 * [Twitter](https://twitter.com/dify_ai). Best for: sharing your applications and hanging out with the community.
-* [Business Contact](mailto:business@dify.ai?subject=[GitHub]Business%20License%20Inquiry). Best for: business inquiries of licensing Dify.AI for commercial use.
 
 ### Direct Meetings
 
-**Help us make Dify better. Reach out directly to us**.
-
 |                       Point of Contact                       |                           Purpose                            |
 | :----------------------------------------------------------: | :----------------------------------------------------------: |
-| <a href='https://cal.com/guchenhe/15min' target='_blank'><img src='https://i.postimg.cc/fWBqSmjP/Git-Hub-README-Button-3x.png' border='0' alt='Git-Hub-README-Button-3x' height="60" width="214"/></a> | Product design feedback, user experience discussions, feature planning and roadmaps. |
-| <a href='https://cal.com/pinkbanana' target='_blank'><img src='https://i.postimg.cc/LsRTh87D/Git-Hub-README-Button-2x.png' border='0' alt='Git-Hub-README-Button-2x' height="60" width="225"/></a> |        Technical support, issues, or feature requests        |
+| <a href='https://cal.com/guchenhe/15min' target='_blank'><img src='https://i.postimg.cc/fWBqSmjP/Git-Hub-README-Button-3x.png' border='0' alt='Git-Hub-README-Button-3x' height="60" width="214"/></a> | Business enquiries & product feedback. |
+| <a href='https://cal.com/pinkbanana' target='_blank'><img src='https://i.postimg.cc/LsRTh87D/Git-Hub-README-Button-2x.png' border='0' alt='Git-Hub-README-Button-2x' height="60" width="225"/></a> | Contributions, issues & feature requests |
 
 ## Security Disclosure
 

README_JA.md

@@ -115,6 +115,7 @@ docker compose up -d
 
 Difyに貢献していただき、コードの提出、問題の報告、新しいアイデアの提供、またはDifyを基に作成した興味深く有用なAIアプリケーションの共有により、Difyをより良いものにするお手伝いを歓迎します。同時に、さまざまなイベント、会議、ソーシャルメディアでDifyを共有することも歓迎します。
 
+- [Github Discussion](https://github.com/langgenius/dify/discussions). 👉：アプリを共有し、コミュニティとコミュニケーション。
 - [GitHub Issues](https://github.com/langgenius/dify/issues)。最適な使用法：Dify.AIの使用中に遭遇するバグやエラー、[貢献ガイド](CONTRIBUTING.md)を参照。
 - [Email サポート](mailto:hello@dify.ai?subject=[GitHub]Questions%20About%20Dify)。最適な使用法：Dify.AIの使用に関する質問。
 - [Discord](https://discord.gg/FngNHpbcY7)。最適な使用法：アプリケーションの共有とコミュニティとの交流。

api/README.md

@@ -17,16 +17,16 @@
    ```bash
    sed -i "/^SECRET_KEY=/c\SECRET_KEY=$(openssl rand -base64 42)" .env
    ```
-3.5 If you use Anaconda, create a new environment and activate it
+4. If you use Anaconda, create a new environment and activate it
    ```bash
    conda create --name dify python=3.10
    conda activate dify
    ```
-4. Install dependencies
+5. Install dependencies
    ```bash
    pip install -r requirements.txt
    ```
-5. Run migrate
+6. Run migrate
 
    Before the first launch, migrate the database to the latest version.
 
@@ -47,9 +47,11 @@
    pip install -r requirements.txt --upgrade --force-reinstall
    ```
 
-6. Start backend:
+7. Start backend:
    ```bash
    flask run --host 0.0.0.0 --port=5001 --debug
    ```
-7. Setup your application by visiting http://localhost:5001/console/api/setup or other apis...
-8. If you need to debug local async processing, you can run `celery -A app.celery worker -P gevent -c 1 --loglevel INFO -Q dataset,generation,mail`, celery can do dataset importing and other async tasks.
+8. Setup your application by visiting http://localhost:5001/console/api/setup or other apis...
+9. If you need to debug local async processing, please start the worker service by running 
+`celery -A app.celery worker -P gevent -c 1 --loglevel INFO -Q dataset,generation,mail`.
+The started celery app handles the async tasks, e.g. dataset importing and documents indexing.

api/config.py

@@ -67,6 +67,7 @@ DEFAULTS = {
     'CODE_EXECUTION_ENDPOINT': '',
     'CODE_EXECUTION_API_KEY': '',
     'TOOL_ICON_CACHE_MAX_AGE': 3600,
+    'MILVUS_DATABASE': 'default',
     'KEYWORD_DATA_SOURCE_TYPE': 'database',
 }
 
@@ -98,7 +99,7 @@ class Config:
         # ------------------------
         # General Configurations.
         # ------------------------
-        self.CURRENT_VERSION = "0.6.0-fix1"
+        self.CURRENT_VERSION = "0.6.1"
         self.COMMIT_SHA = get_env('COMMIT_SHA')
         self.EDITION = "SELF_HOSTED"
         self.DEPLOY_ENV = get_env('DEPLOY_ENV')
@@ -212,6 +213,7 @@ class Config:
         self.MILVUS_USER = get_env('MILVUS_USER')
         self.MILVUS_PASSWORD = get_env('MILVUS_PASSWORD')
         self.MILVUS_SECURE = get_env('MILVUS_SECURE')
+        self.MILVUS_DATABASE = get_env('MILVUS_DATABASE')
 
         # weaviate settings
         self.WEAVIATE_ENDPOINT = get_env('WEAVIATE_ENDPOINT')

api/controllers/console/explore/conversation.py

@@ -6,6 +6,7 @@ from werkzeug.exceptions import NotFound
 from controllers.console import api
 from controllers.console.explore.error import NotChatAppError
 from controllers.console.explore.wraps import InstalledAppResource
+from core.app.entities.app_invoke_entities import InvokeFrom
 from fields.conversation_fields import conversation_infinite_scroll_pagination_fields, simple_conversation_fields
 from libs.helper import uuid_value
 from models.model import AppMode
@@ -39,8 +40,8 @@ class ConversationListApi(InstalledAppResource):
                 user=current_user,
                 last_id=args['last_id'],
                 limit=args['limit'],
+                invoke_from=InvokeFrom.EXPLORE,
                 pinned=pinned,
-                exclude_debug_conversation=True
             )
         except LastConversationNotExistsError:
             raise NotFound("Last Conversation Not Exists.")

api/controllers/service_api/app/conversation.py

@@ -6,6 +6,7 @@ import services
 from controllers.service_api import api
 from controllers.service_api.app.error import NotChatAppError
 from controllers.service_api.wraps import FetchUserArg, WhereisUserArg, validate_app_token
+from core.app.entities.app_invoke_entities import InvokeFrom
 from fields.conversation_fields import conversation_infinite_scroll_pagination_fields, simple_conversation_fields
 from libs.helper import uuid_value
 from models.model import App, AppMode, EndUser
@@ -27,7 +28,13 @@ class ConversationApi(Resource):
         args = parser.parse_args()
 
         try:
-            return ConversationService.pagination_by_last_id(app_model, end_user, args['last_id'], args['limit'])
+            return ConversationService.pagination_by_last_id(
+                app_model=app_model,
+                user=end_user,
+                last_id=args['last_id'],
+                limit=args['limit'],
+                invoke_from=InvokeFrom.SERVICE_API
+            )
         except services.errors.conversation.LastConversationNotExistsError:
             raise NotFound("Last Conversation Not Exists.")
 

api/controllers/web/conversation.py

@@ -5,6 +5,7 @@ from werkzeug.exceptions import NotFound
 from controllers.web import api
 from controllers.web.error import NotChatAppError
 from controllers.web.wraps import WebApiResource
+from core.app.entities.app_invoke_entities import InvokeFrom
 from fields.conversation_fields import conversation_infinite_scroll_pagination_fields, simple_conversation_fields
 from libs.helper import uuid_value
 from models.model import AppMode
@@ -37,7 +38,8 @@ class ConversationListApi(WebApiResource):
                 user=end_user,
                 last_id=args['last_id'],
                 limit=args['limit'],
-                pinned=pinned
+                invoke_from=InvokeFrom.WEB_APP,
+                pinned=pinned,
             )
         except LastConversationNotExistsError:
             raise NotFound("Last Conversation Not Exists.")

api/core/agent/cot_agent_runner.py

@@ -687,4 +687,4 @@ class CotAgentRunner(BaseAgentRunner):
         try:
             return json.dumps(tools, ensure_ascii=False)
         except json.JSONDecodeError:
-            return json.dumps(tools)
+            return json.dumps(tools)

api/core/agent/fc_agent_runner.py

@@ -207,19 +207,25 @@ class FunctionCallAgentRunner(BaseAgentRunner):
                     )
                 )
 
+            assistant_message = AssistantPromptMessage(
+                content='',
+                tool_calls=[]
+            )
             if tool_calls:
-                prompt_messages.append(AssistantPromptMessage(
-                    content='',
-                    name='',
-                    tool_calls=[AssistantPromptMessage.ToolCall(
+                assistant_message.tool_calls=[
+                    AssistantPromptMessage.ToolCall(
                         id=tool_call[0],
                         type='function',
                         function=AssistantPromptMessage.ToolCall.ToolCallFunction(
                             name=tool_call[1],
                             arguments=json.dumps(tool_call[2], ensure_ascii=False)
                         )
-                    ) for tool_call in tool_calls]
-                ))
+                    ) for tool_call in tool_calls
+                ]
+            else:
+                assistant_message.content = response
+            
+            prompt_messages.append(assistant_message)
 
             # save thought
             self.save_agent_thought(
@@ -239,12 +245,6 @@ class FunctionCallAgentRunner(BaseAgentRunner):
             
             final_answer += response + '\n'
 
-            # update prompt messages
-            if response.strip():
-                prompt_messages.append(AssistantPromptMessage(
-                    content=response,
-                ))
-            
             # call tools
             tool_responses = []
             for tool_call_id, tool_call_name, tool_call_args in tool_calls:

api/core/callback_handler/agent_tool_callback_handler.py

@@ -1,12 +1,32 @@
 import os
-from typing import Any, Optional, Union
+from typing import Any, Optional, TextIO, Union
 
-from langchain.callbacks.base import BaseCallbackHandler
-from langchain.input import print_text
 from pydantic import BaseModel
 
+_TEXT_COLOR_MAPPING = {
+    "blue": "36;1",
+    "yellow": "33;1",
+    "pink": "38;5;200",
+    "green": "32;1",
+    "red": "31;1",
+}
 
-class DifyAgentCallbackHandler(BaseCallbackHandler, BaseModel):
+def get_colored_text(text: str, color: str) -> str:
+    """Get colored text."""
+    color_str = _TEXT_COLOR_MAPPING[color]
+    return f"\u001b[{color_str}m\033[1;3m{text}\u001b[0m"
+
+
+def print_text(
+    text: str, color: Optional[str] = None, end: str = "", file: Optional[TextIO] = None
+) -> None:
+    """Print text with highlighting and no end characters."""
+    text_to_print = get_colored_text(text, color) if color else text
+    print(text_to_print, end=end, file=file)
+    if file:
+        file.flush()  # ensure all printed content are written to file
+
+class DifyAgentCallbackHandler(BaseModel):
     """Callback Handler that prints to std out."""
     color: Optional[str] = ''
     current_loop = 1

api/core/embedding/cached_embedding.py

@@ -41,7 +41,8 @@ class CacheEmbedding(Embeddings):
             embedding_queue_embeddings = []
             try:
                 model_type_instance = cast(TextEmbeddingModel, self._model_instance.model_type_instance)
-                model_schema = model_type_instance.get_model_schema(self._model_instance.model, self._model_instance.credentials)
+                model_schema = model_type_instance.get_model_schema(self._model_instance.model,
+                                                                    self._model_instance.credentials)
                 max_chunks = model_schema.model_properties[ModelPropertyKey.MAX_CHUNKS] \
                     if model_schema and ModelPropertyKey.MAX_CHUNKS in model_schema.model_properties else 1
                 for i in range(0, len(embedding_queue_texts), max_chunks):
@@ -61,17 +62,20 @@ class CacheEmbedding(Embeddings):
                         except Exception as e:
                             logging.exception('Failed transform embedding: ', e)
                 cache_embeddings = []
-                for i, embedding in zip(embedding_queue_indices, embedding_queue_embeddings):
-                    text_embeddings[i] = embedding
-                    hash = helper.generate_text_hash(texts[i])
-                    if hash not in cache_embeddings:
-                        embedding_cache = Embedding(model_name=self._model_instance.model,
-                                              hash=hash,
-                                              provider_name=self._model_instance.provider)
-                        embedding_cache.set_embedding(embedding)
-                        db.session.add(embedding_cache)
-                        cache_embeddings.append(hash)
-                db.session.commit()
+                try:
+                    for i, embedding in zip(embedding_queue_indices, embedding_queue_embeddings):
+                        text_embeddings[i] = embedding
+                        hash = helper.generate_text_hash(texts[i])
+                        if hash not in cache_embeddings:
+                            embedding_cache = Embedding(model_name=self._model_instance.model,
+                                                        hash=hash,
+                                                        provider_name=self._model_instance.provider)
+                            embedding_cache.set_embedding(embedding)
+                            db.session.add(embedding_cache)
+                            cache_embeddings.append(hash)
+                    db.session.commit()
+                except IntegrityError:
+                    db.session.rollback()
             except Exception as ex:
                 db.session.rollback()
                 logger.error('Failed to embed documents: ', ex)

api/core/helper/code_executor/javascript_transformer.py

@@ -29,16 +29,16 @@ class NodeJsTemplateTransformer(TemplateTransformer):
         :param inputs: inputs
         :return:
         """
-        
+
         # transform inputs to json string
-        inputs_str = json.dumps(inputs, indent=4)
+        inputs_str = json.dumps(inputs, indent=4, ensure_ascii=False)
 
         # replace code and inputs
         runner = NODEJS_RUNNER.replace('{{code}}', code)
         runner = runner.replace('{{inputs}}', inputs_str)
 
         return runner, NODEJS_PRELOAD
-    
+
     @classmethod
     def transform_response(cls, response: str) -> dict:
         """

api/core/helper/code_executor/jina2_transformer.py

@@ -62,10 +62,10 @@ class Jinja2TemplateTransformer(TemplateTransformer):
 
         # transform jinja2 template to python code
         runner = PYTHON_RUNNER.replace('{{code}}', code)
-        runner = runner.replace('{{inputs}}', json.dumps(inputs, indent=4))
+        runner = runner.replace('{{inputs}}', json.dumps(inputs, indent=4, ensure_ascii=False))
 
         return runner, JINJA2_PRELOAD
-    
+
     @classmethod
     def transform_response(cls, response: str) -> dict:
         """
@@ -81,4 +81,4 @@ class Jinja2TemplateTransformer(TemplateTransformer):
 
         return {
             'result': result
-        }
+        }

api/core/helper/code_executor/python_transformer.py

@@ -34,7 +34,7 @@ class PythonTemplateTransformer(TemplateTransformer):
         """
         
         # transform inputs to json string
-        inputs_str = json.dumps(inputs, indent=4)
+        inputs_str = json.dumps(inputs, indent=4, ensure_ascii=False)
 
         # replace code and inputs
         runner = PYTHON_RUNNER.replace('{{code}}', code)

api/core/indexing_runner.py

@@ -19,6 +19,7 @@ from core.model_manager import ModelInstance, ModelManager
 from core.model_runtime.entities.model_entities import ModelType, PriceType
 from core.model_runtime.model_providers.__base.large_language_model import LargeLanguageModel
 from core.model_runtime.model_providers.__base.text_embedding_model import TextEmbeddingModel
+from core.rag.datasource.keyword.keyword_factory import Keyword
 from core.rag.extractor.entity.extract_setting import ExtractSetting
 from core.rag.index_processor.index_processor_base import BaseIndexProcessor
 from core.rag.index_processor.index_processor_factory import IndexProcessorFactory
@@ -657,18 +658,25 @@ class IndexingRunner:
         if embedding_model_instance:
             embedding_model_type_instance = embedding_model_instance.model_type_instance
             embedding_model_type_instance = cast(TextEmbeddingModel, embedding_model_type_instance)
-        with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
-            futures = []
-            for i in range(0, len(documents), chunk_size):
-                chunk_documents = documents[i:i + chunk_size]
-                futures.append(executor.submit(self._process_chunk, current_app._get_current_object(), index_processor,
-                                               chunk_documents, dataset,
-                                               dataset_document, embedding_model_instance,
-                                               embedding_model_type_instance))
+        # create keyword index
+        create_keyword_thread = threading.Thread(target=self._process_keyword_index,
+                                                 args=(current_app._get_current_object(),
+                                                       dataset.id, dataset_document.id, documents))
+        create_keyword_thread.start()
+        if dataset.indexing_technique == 'high_quality':
+            with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
+                futures = []
+                for i in range(0, len(documents), chunk_size):
+                    chunk_documents = documents[i:i + chunk_size]
+                    futures.append(executor.submit(self._process_chunk, current_app._get_current_object(), index_processor,
+                                                   chunk_documents, dataset,
+                                                   dataset_document, embedding_model_instance,
+                                                   embedding_model_type_instance))
 
-            for future in futures:
-                tokens += future.result()
+                for future in futures:
+                    tokens += future.result()
 
+        create_keyword_thread.join()
         indexing_end_at = time.perf_counter()
 
         # update document status to completed
@@ -682,6 +690,27 @@ class IndexingRunner:
             }
         )
 
+    def _process_keyword_index(self, flask_app, dataset_id, document_id, documents):
+        with flask_app.app_context():
+            dataset = Dataset.query.filter_by(id=dataset_id).first()
+            if not dataset:
+                raise ValueError("no dataset found")
+            keyword = Keyword(dataset)
+            keyword.create(documents)
+            if dataset.indexing_technique != 'high_quality':
+                document_ids = [document.metadata['doc_id'] for document in documents]
+                db.session.query(DocumentSegment).filter(
+                    DocumentSegment.document_id == document_id,
+                    DocumentSegment.index_node_id.in_(document_ids),
+                    DocumentSegment.status == "indexing"
+                ).update({
+                    DocumentSegment.status: "completed",
+                    DocumentSegment.enabled: True,
+                    DocumentSegment.completed_at: datetime.datetime.utcnow()
+                })
+
+                db.session.commit()
+
     def _process_chunk(self, flask_app, index_processor, chunk_documents, dataset, dataset_document,
                        embedding_model_instance, embedding_model_type_instance):
         with flask_app.app_context():
@@ -700,7 +729,7 @@ class IndexingRunner:
                 )
 
             # load index
-            index_processor.load(dataset, chunk_documents)
+            index_processor.load(dataset, chunk_documents, with_keywords=False)
 
             document_ids = [document.metadata['doc_id'] for document in chunk_documents]
             db.session.query(DocumentSegment).filter(

api/core/memory/token_buffer_memory.py

@@ -3,6 +3,7 @@ from core.file.message_file_parser import MessageFileParser
 from core.model_manager import ModelInstance
 from core.model_runtime.entities.message_entities import (
     AssistantPromptMessage,
+    ImagePromptMessageContent,
     PromptMessage,
     PromptMessageRole,
     TextPromptMessageContent,
@@ -124,7 +125,17 @@ class TokenBufferMemory:
             else:
                 continue
 
-            message = f"{role}: {m.content}"
-            string_messages.append(message)
+            if isinstance(m.content, list):
+                inner_msg = ""
+                for content in m.content:
+                    if isinstance(content, TextPromptMessageContent):
+                        inner_msg += f"{content.data}\n"
+                    elif isinstance(content, ImagePromptMessageContent):
+                        inner_msg += "[image]\n"
+
+                string_messages.append(f"{role}: {inner_msg.strip()}")
+            else:
+                message = f"{role}: {m.content}"
+                string_messages.append(message)
 
         return "\n".join(string_messages)

api/core/model_runtime/model_providers/bedrock/bedrock.yaml

@@ -74,7 +74,7 @@ provider_credential_schema:
       label:
         en_US: Available Model Name
         zh_Hans: 可用模型名称
-      type: secret-input
+      type: text-input
       placeholder:
         en_US: A model you have access to (e.g. amazon.titan-text-lite-v1) for validation.
         zh_Hans: 为了进行验证，请输入一个您可用的模型名称 (例如：amazon.titan-text-lite-v1)

api/core/model_runtime/model_providers/bedrock/llm/llm.py

@@ -402,25 +402,25 @@ class BedrockLargeLanguageModel(LargeLanguageModel):
         :param credentials: model credentials
         :return:
         """
-
-        if "anthropic.claude-3" in model:
-            try:
-                self._invoke_claude(model=model,
-                                        credentials=credentials,
-                                        prompt_messages=[{"role": "user", "content": "ping"}],
-                                        model_parameters={},
-                                        stop=None,
-                                        stream=False)
-
-            except Exception as ex:
-                raise CredentialsValidateFailedError(str(ex))
-
+        required_params = {}
+        if "anthropic" in model:
+            required_params = {
+                "max_tokens": 32,
+            }
+        elif "ai21" in model:
+            # ValidationException: Malformed input request: #/temperature: expected type: Number, found: Null#/maxTokens: expected type: Integer, found: Null#/topP: expected type: Number, found: Null, please reformat your input and try again.
+            required_params = {
+                "temperature": 0.7,
+                "topP": 0.9,
+                "maxTokens": 32,
+            }
+            
         try:
             ping_message = UserPromptMessage(content="ping")
-            self._generate(model=model,
+            self._invoke(model=model,
                            credentials=credentials,
                            prompt_messages=[ping_message],
-                           model_parameters={},
+                           model_parameters=required_params,
                            stream=False)
         
         except ClientError as ex:

api/core/model_runtime/model_providers/cohere/llm/llm.py

@@ -297,7 +297,6 @@ class CohereLargeLanguageModel(LargeLanguageModel):
             chat_history=chat_histories,
             model=real_model,
             stream=stream,
-            return_preamble=True,
             **model_parameters,
         )
 

api/core/model_runtime/model_providers/moonshot/llm/llm.py

@@ -1,8 +1,31 @@
+import json
 from collections.abc import Generator
-from typing import Optional, Union
+from typing import Optional, Union, cast
 
-from core.model_runtime.entities.llm_entities import LLMResult
-from core.model_runtime.entities.message_entities import PromptMessage, PromptMessageTool
+import requests
+
+from core.model_runtime.entities.common_entities import I18nObject
+from core.model_runtime.entities.llm_entities import LLMMode, LLMResult, LLMResultChunk, LLMResultChunkDelta
+from core.model_runtime.entities.message_entities import (
+    AssistantPromptMessage,
+    ImagePromptMessageContent,
+    PromptMessage,
+    PromptMessageContent,
+    PromptMessageContentType,
+    PromptMessageTool,
+    SystemPromptMessage,
+    ToolPromptMessage,
+    UserPromptMessage,
+)
+from core.model_runtime.entities.model_entities import (
+    AIModelEntity,
+    FetchFrom,
+    ModelFeature,
+    ModelPropertyKey,
+    ModelType,
+    ParameterRule,
+    ParameterType,
+)
 from core.model_runtime.model_providers.openai_api_compatible.llm.llm import OAIAPICompatLargeLanguageModel
 
 
@@ -13,6 +36,7 @@ class MoonshotLargeLanguageModel(OAIAPICompatLargeLanguageModel):
                 stream: bool = True, user: Optional[str] = None) \
             -> Union[LLMResult, Generator]:
         self._add_custom_parameters(credentials)
+        self._add_function_call(model, credentials)
         user = user[:32] if user else None
         return super()._invoke(model, credentials, prompt_messages, model_parameters, tools, stop, stream, user)
 
@@ -20,7 +44,293 @@ class MoonshotLargeLanguageModel(OAIAPICompatLargeLanguageModel):
         self._add_custom_parameters(credentials)
         super().validate_credentials(model, credentials)
 
-    @staticmethod
-    def _add_custom_parameters(credentials: dict) -> None:
+    def get_customizable_model_schema(self, model: str, credentials: dict) -> AIModelEntity | None:
+        return AIModelEntity(
+            model=model,
+            label=I18nObject(en_US=model, zh_Hans=model),
+            model_type=ModelType.LLM,
+            features=[ModelFeature.TOOL_CALL, ModelFeature.MULTI_TOOL_CALL, ModelFeature.STREAM_TOOL_CALL] 
+                if credentials.get('function_calling_type') == 'tool_call' 
+                else [],
+            fetch_from=FetchFrom.CUSTOMIZABLE_MODEL,
+            model_properties={
+                ModelPropertyKey.CONTEXT_SIZE: int(credentials.get('context_size', 4096)),
+                ModelPropertyKey.MODE: LLMMode.CHAT.value,
+            },
+            parameter_rules=[
+                ParameterRule(
+                    name='temperature',
+                    use_template='temperature',
+                    label=I18nObject(en_US='Temperature', zh_Hans='温度'),
+                    type=ParameterType.FLOAT,
+                ),
+                ParameterRule(
+                    name='max_tokens',
+                    use_template='max_tokens',
+                    default=512,
+                    min=1,
+                    max=int(credentials.get('max_tokens', 4096)),
+                    label=I18nObject(en_US='Max Tokens', zh_Hans='最大标记'),
+                    type=ParameterType.INT,
+                ),
+                ParameterRule(
+                    name='top_p',
+                    use_template='top_p',
+                    label=I18nObject(en_US='Top P', zh_Hans='Top P'),
+                    type=ParameterType.FLOAT,
+                ),
+            ]
+        )
+
+    def _add_custom_parameters(self, credentials: dict) -> None:
         credentials['mode'] = 'chat'
         credentials['endpoint_url'] = 'https://api.moonshot.cn/v1'
+
+    def _add_function_call(self, model: str, credentials: dict) -> None:
+        model_schema = self.get_model_schema(model, credentials)
+        if model_schema and set([
+            ModelFeature.TOOL_CALL, ModelFeature.MULTI_TOOL_CALL
+        ]).intersection(model_schema.features or []):
+            credentials['function_calling_type'] = 'tool_call'
+
+    def _convert_prompt_message_to_dict(self, message: PromptMessage) -> dict:
+        """
+        Convert PromptMessage to dict for OpenAI API format
+        """
+        if isinstance(message, UserPromptMessage):
+            message = cast(UserPromptMessage, message)
+            if isinstance(message.content, str):
+                message_dict = {"role": "user", "content": message.content}
+            else:
+                sub_messages = []
+                for message_content in message.content:
+                    if message_content.type == PromptMessageContentType.TEXT:
+                        message_content = cast(PromptMessageContent, message_content)
+                        sub_message_dict = {
+                            "type": "text",
+                            "text": message_content.data
+                        }
+                        sub_messages.append(sub_message_dict)
+                    elif message_content.type == PromptMessageContentType.IMAGE:
+                        message_content = cast(ImagePromptMessageContent, message_content)
+                        sub_message_dict = {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": message_content.data,
+                                "detail": message_content.detail.value
+                            }
+                        }
+                        sub_messages.append(sub_message_dict)
+                message_dict = {"role": "user", "content": sub_messages}
+        elif isinstance(message, AssistantPromptMessage):
+            message = cast(AssistantPromptMessage, message)
+            message_dict = {"role": "assistant", "content": message.content}
+            if message.tool_calls:
+                message_dict["tool_calls"] = []
+                for function_call in message.tool_calls:
+                    message_dict["tool_calls"].append({
+                        "id": function_call.id,
+                        "type": function_call.type,
+                        "function": {
+                            "name": f"functions.{function_call.function.name}",
+                            "arguments": function_call.function.arguments
+                        }
+                    })
+        elif isinstance(message, ToolPromptMessage):
+            message = cast(ToolPromptMessage, message)
+            message_dict = {"role": "tool", "content": message.content, "tool_call_id": message.tool_call_id}
+            if not message.name.startswith("functions."):
+                message.name = f"functions.{message.name}"
+        elif isinstance(message, SystemPromptMessage):
+            message = cast(SystemPromptMessage, message)
+            message_dict = {"role": "system", "content": message.content}
+        else:
+            raise ValueError(f"Got unknown type {message}")
+
+        if message.name:
+            message_dict["name"] = message.name
+
+        return message_dict
+
+    def _extract_response_tool_calls(self, response_tool_calls: list[dict]) -> list[AssistantPromptMessage.ToolCall]:
+        """
+        Extract tool calls from response
+
+        :param response_tool_calls: response tool calls
+        :return: list of tool calls
+        """
+        tool_calls = []
+        if response_tool_calls:
+            for response_tool_call in response_tool_calls:
+                function = AssistantPromptMessage.ToolCall.ToolCallFunction(
+                    name=response_tool_call["function"]["name"] if response_tool_call.get("function", {}).get("name") else "",
+                    arguments=response_tool_call["function"]["arguments"] if response_tool_call.get("function", {}).get("arguments") else ""
+                )
+
+                tool_call = AssistantPromptMessage.ToolCall(
+                    id=response_tool_call["id"] if response_tool_call.get("id") else "",
+                    type=response_tool_call["type"] if response_tool_call.get("type") else "",
+                    function=function
+                )
+                tool_calls.append(tool_call)
+
+        return tool_calls
+
+    def _handle_generate_stream_response(self, model: str, credentials: dict, response: requests.Response,
+                                         prompt_messages: list[PromptMessage]) -> Generator:
+        """
+        Handle llm stream response
+
+        :param model: model name
+        :param credentials: model credentials
+        :param response: streamed response
+        :param prompt_messages: prompt messages
+        :return: llm response chunk generator
+        """
+        full_assistant_content = ''
+        chunk_index = 0
+
+        def create_final_llm_result_chunk(index: int, message: AssistantPromptMessage, finish_reason: str) \
+                -> LLMResultChunk:
+            # calculate num tokens
+            prompt_tokens = self._num_tokens_from_string(model, prompt_messages[0].content)
+            completion_tokens = self._num_tokens_from_string(model, full_assistant_content)
+
+            # transform usage
+            usage = self._calc_response_usage(model, credentials, prompt_tokens, completion_tokens)
+
+            return LLMResultChunk(
+                model=model,
+                prompt_messages=prompt_messages,
+                delta=LLMResultChunkDelta(
+                    index=index,
+                    message=message,
+                    finish_reason=finish_reason,
+                    usage=usage
+                )
+            )
+
+        tools_calls: list[AssistantPromptMessage.ToolCall] = []
+        finish_reason = "Unknown"
+
+        def increase_tool_call(new_tool_calls: list[AssistantPromptMessage.ToolCall]):
+            def get_tool_call(tool_name: str):
+                if not tool_name:
+                    return tools_calls[-1]
+
+                tool_call = next((tool_call for tool_call in tools_calls if tool_call.function.name == tool_name), None)
+                if tool_call is None:
+                    tool_call = AssistantPromptMessage.ToolCall(
+                        id='',
+                        type='',
+                        function=AssistantPromptMessage.ToolCall.ToolCallFunction(name=tool_name, arguments="")
+                    )
+                    tools_calls.append(tool_call)
+
+                return tool_call
+
+            for new_tool_call in new_tool_calls:
+                # get tool call
+                tool_call = get_tool_call(new_tool_call.function.name)
+                # update tool call
+                if new_tool_call.id:
+                    tool_call.id = new_tool_call.id
+                if new_tool_call.type:
+                    tool_call.type = new_tool_call.type
+                if new_tool_call.function.name:
+                    # remove the functions. prefix
+                    if new_tool_call.function.name.startswith('functions.'):
+                        parts = new_tool_call.function.name.split('functions.')
+                        if len(parts) > 1:
+                            new_tool_call.function.name = parts[1]
+                    tool_call.function.name = new_tool_call.function.name
+                if new_tool_call.function.arguments:
+                    tool_call.function.arguments += new_tool_call.function.arguments
+
+        for chunk in response.iter_lines(decode_unicode=True, delimiter="\n\n"):
+            if chunk:
+                # ignore sse comments
+                if chunk.startswith(':'):
+                    continue
+                decoded_chunk = chunk.strip().lstrip('data: ').lstrip()
+                chunk_json = None
+                try:
+                    chunk_json = json.loads(decoded_chunk)
+                # stream ended
+                except json.JSONDecodeError as e:
+                    yield create_final_llm_result_chunk(
+                        index=chunk_index + 1,
+                        message=AssistantPromptMessage(content=""),
+                        finish_reason="Non-JSON encountered."
+                    )
+                    break
+                if not chunk_json or len(chunk_json['choices']) == 0:
+                    continue
+
+                choice = chunk_json['choices'][0]
+                finish_reason = chunk_json['choices'][0].get('finish_reason')
+                chunk_index += 1
+
+                if 'delta' in choice:
+                    delta = choice['delta']
+                    delta_content = delta.get('content')
+
+                    assistant_message_tool_calls = delta.get('tool_calls', None)
+                    # assistant_message_function_call = delta.delta.function_call
+
+                    # extract tool calls from response
+                    if assistant_message_tool_calls:
+                        tool_calls = self._extract_response_tool_calls(assistant_message_tool_calls)
+                        increase_tool_call(tool_calls)
+
+                    if delta_content is None or delta_content == '':
+                        continue
+
+                    # transform assistant message to prompt message
+                    assistant_prompt_message = AssistantPromptMessage(
+                        content=delta_content,
+                        tool_calls=tool_calls if assistant_message_tool_calls else []
+                    )
+
+                    full_assistant_content += delta_content
+                elif 'text' in choice:
+                    choice_text = choice.get('text', '')
+                    if choice_text == '':
+                        continue
+
+                    # transform assistant message to prompt message
+                    assistant_prompt_message = AssistantPromptMessage(content=choice_text)
+                    full_assistant_content += choice_text
+                else:
+                    continue
+
+                # check payload indicator for completion
+                yield LLMResultChunk(
+                    model=model,
+                    prompt_messages=prompt_messages,
+                    delta=LLMResultChunkDelta(
+                        index=chunk_index,
+                        message=assistant_prompt_message,
+                    )
+                )
+
+            chunk_index += 1
+        
+        if tools_calls:
+            yield LLMResultChunk(
+                model=model,
+                prompt_messages=prompt_messages,
+                delta=LLMResultChunkDelta(
+                    index=chunk_index,
+                    message=AssistantPromptMessage(
+                        tool_calls=tools_calls,
+                        content=""
+                    ),
+                )
+            )
+
+        yield create_final_llm_result_chunk(
+            index=chunk_index,
+            message=AssistantPromptMessage(content=""),
+            finish_reason=finish_reason
+        )

api/core/model_runtime/model_providers/moonshot/moonshot.yaml

@@ -20,6 +20,7 @@ supported_model_types:
   - llm
 configurate_methods:
   - predefined-model
+  - customizable-model
 provider_credential_schema:
   credential_form_schemas:
     - variable: api_key
@@ -30,3 +31,51 @@ provider_credential_schema:
       placeholder:
         zh_Hans: 在此输入您的 API Key
         en_US: Enter your API Key
+model_credential_schema:
+  model:
+    label:
+      en_US: Model Name
+      zh_Hans: 模型名称
+    placeholder:
+      en_US: Enter your model name
+      zh_Hans: 输入模型名称
+  credential_form_schemas:
+    - variable: api_key
+      label:
+        en_US: API Key
+      type: secret-input
+      required: true
+      placeholder:
+        zh_Hans: 在此输入您的 API Key
+        en_US: Enter your API Key
+    - variable: context_size
+      label:
+        zh_Hans: 模型上下文长度
+        en_US: Model context size
+      required: true
+      type: text-input
+      default: '4096'
+      placeholder:
+        zh_Hans: 在此输入您的模型上下文长度
+        en_US: Enter your Model context size
+    - variable: max_tokens
+      label:
+        zh_Hans: 最大 token 上限
+        en_US: Upper bound for max tokens
+      default: '4096'
+      type: text-input
+    - variable: function_calling_type
+      label:
+        en_US: Function calling
+      type: select
+      required: false
+      default: no_call
+      options:
+        - value: no_call
+          label:
+            en_US: Not supported
+            zh_Hans: 不支持
+        - value: tool_call
+          label:
+            en_US: Tool Call
+            zh_Hans: Tool Call

api/core/model_runtime/model_providers/openai_api_compatible/llm/llm.py

@@ -378,6 +378,34 @@ class OAIAPICompatLargeLanguageModel(_CommonOAI_API_Compat, LargeLanguageModel):
         delimiter = credentials.get("stream_mode_delimiter", "\n\n")
         delimiter = codecs.decode(delimiter, "unicode_escape")
 
+        tools_calls: list[AssistantPromptMessage.ToolCall] = []
+
+        def increase_tool_call(new_tool_calls: list[AssistantPromptMessage.ToolCall]):
+            def get_tool_call(tool_call_id: str):
+                tool_call = next(
+                    (tool_call for tool_call in tools_calls if tool_call.id == tool_call_id), None
+                )
+                if tool_call is None:
+                    tool_call = AssistantPromptMessage.ToolCall(
+                        id='', 
+                        type='function', 
+                        function=AssistantPromptMessage.ToolCall.ToolCallFunction(
+                            name='',
+                            arguments=''
+                        )
+                    )
+                    tools_calls.append(tool_call)
+                return tool_call
+
+            for new_tool_call in new_tool_calls:
+                # get tool call
+                tool_call = get_tool_call(new_tool_call.id)
+                # update tool call
+                tool_call.id = new_tool_call.id
+                tool_call.type = new_tool_call.type
+                tool_call.function.name = new_tool_call.function.name
+                tool_call.function.arguments += new_tool_call.function.arguments
+
         for chunk in response.iter_lines(decode_unicode=True, delimiter=delimiter):
             if chunk:
                 # ignore sse comments
@@ -405,8 +433,6 @@ class OAIAPICompatLargeLanguageModel(_CommonOAI_API_Compat, LargeLanguageModel):
                 if 'delta' in choice:
                     delta = choice['delta']
                     delta_content = delta.get('content')
-                    if delta_content is None or delta_content == '':
-                        continue
 
                     assistant_message_tool_calls = delta.get('tool_calls', None)
                     # assistant_message_function_call = delta.delta.function_call
@@ -414,6 +440,11 @@ class OAIAPICompatLargeLanguageModel(_CommonOAI_API_Compat, LargeLanguageModel):
                     # extract tool calls from response
                     if assistant_message_tool_calls:
                         tool_calls = self._extract_response_tool_calls(assistant_message_tool_calls)
+                        increase_tool_call(tool_calls)
+
+                    if delta_content is None or delta_content == '':
+                        continue
+
                     # function_call = self._extract_response_function_call(assistant_message_function_call)
                     # tool_calls = [function_call] if function_call else []
 
@@ -437,6 +468,18 @@ class OAIAPICompatLargeLanguageModel(_CommonOAI_API_Compat, LargeLanguageModel):
 
                 # check payload indicator for completion
                 if finish_reason is not None:
+                    yield LLMResultChunk(
+                        model=model,
+                        prompt_messages=prompt_messages,
+                        delta=LLMResultChunkDelta(
+                            index=chunk_index,
+                            message=AssistantPromptMessage(
+                                tool_calls=tools_calls,
+                            ),
+                            finish_reason=finish_reason
+                        )
+                    )
+
                     yield create_final_llm_result_chunk(
                         index=chunk_index,
                         message=assistant_prompt_message,
@@ -735,4 +778,4 @@ class OAIAPICompatLargeLanguageModel(_CommonOAI_API_Compat, LargeLanguageModel):
                 function=function
             )
 
-        return tool_call
+        return tool_call

api/core/model_runtime/model_providers/wenxin/llm/ernie-3.5-4k-0205.yaml

@@ -1,6 +1,6 @@
-model: ernie-3.5-8k
+model: ernie-3.5-4k-0205
 label:
-  en_US: Ernie-3.5-8K
+  en_US: Ernie-3.5-4k-0205
 model_type: llm
 features:
   - agent-thought

api/core/rag/datasource/keyword/jieba/jieba.py

@@ -24,56 +24,64 @@ class Jieba(BaseKeyword):
         self._config = KeywordTableConfig()
 
     def create(self, texts: list[Document], **kwargs) -> BaseKeyword:
-        keyword_table_handler = JiebaKeywordTableHandler()
-        keyword_table = self._get_dataset_keyword_table()
-        for text in texts:
-            keywords = keyword_table_handler.extract_keywords(text.page_content, self._config.max_keywords_per_chunk)
-            self._update_segment_keywords(self.dataset.id, text.metadata['doc_id'], list(keywords))
-            keyword_table = self._add_text_to_keyword_table(keyword_table, text.metadata['doc_id'], list(keywords))
+        lock_name = 'keyword_indexing_lock_{}'.format(self.dataset.id)
+        with redis_client.lock(lock_name, timeout=600):
+            keyword_table_handler = JiebaKeywordTableHandler()
+            keyword_table = self._get_dataset_keyword_table()
+            for text in texts:
+                keywords = keyword_table_handler.extract_keywords(text.page_content, self._config.max_keywords_per_chunk)
+                self._update_segment_keywords(self.dataset.id, text.metadata['doc_id'], list(keywords))
+                keyword_table = self._add_text_to_keyword_table(keyword_table, text.metadata['doc_id'], list(keywords))
 
-        self._save_dataset_keyword_table(keyword_table)
+            self._save_dataset_keyword_table(keyword_table)
 
-        return self
+            return self
 
     def add_texts(self, texts: list[Document], **kwargs):
-        keyword_table_handler = JiebaKeywordTableHandler()
+        lock_name = 'keyword_indexing_lock_{}'.format(self.dataset.id)
+        with redis_client.lock(lock_name, timeout=600):
+            keyword_table_handler = JiebaKeywordTableHandler()
 
-        keyword_table = self._get_dataset_keyword_table()
-        keywords_list = kwargs.get('keywords_list', None)
-        for i in range(len(texts)):
-            text = texts[i]
-            if keywords_list:
-                keywords = keywords_list[i]
-            else:
-                keywords = keyword_table_handler.extract_keywords(text.page_content, self._config.max_keywords_per_chunk)
-            self._update_segment_keywords(self.dataset.id, text.metadata['doc_id'], list(keywords))
-            keyword_table = self._add_text_to_keyword_table(keyword_table, text.metadata['doc_id'], list(keywords))
+            keyword_table = self._get_dataset_keyword_table()
+            keywords_list = kwargs.get('keywords_list', None)
+            for i in range(len(texts)):
+                text = texts[i]
+                if keywords_list:
+                    keywords = keywords_list[i]
+                else:
+                    keywords = keyword_table_handler.extract_keywords(text.page_content, self._config.max_keywords_per_chunk)
+                self._update_segment_keywords(self.dataset.id, text.metadata['doc_id'], list(keywords))
+                keyword_table = self._add_text_to_keyword_table(keyword_table, text.metadata['doc_id'], list(keywords))
 
-        self._save_dataset_keyword_table(keyword_table)
+            self._save_dataset_keyword_table(keyword_table)
 
     def text_exists(self, id: str) -> bool:
         keyword_table = self._get_dataset_keyword_table()
         return id in set.union(*keyword_table.values())
 
     def delete_by_ids(self, ids: list[str]) -> None:
-        keyword_table = self._get_dataset_keyword_table()
-        keyword_table = self._delete_ids_from_keyword_table(keyword_table, ids)
+        lock_name = 'keyword_indexing_lock_{}'.format(self.dataset.id)
+        with redis_client.lock(lock_name, timeout=600):
+            keyword_table = self._get_dataset_keyword_table()
+            keyword_table = self._delete_ids_from_keyword_table(keyword_table, ids)
 
-        self._save_dataset_keyword_table(keyword_table)
+            self._save_dataset_keyword_table(keyword_table)
 
     def delete_by_document_id(self, document_id: str):
-        # get segment ids by document_id
-        segments = db.session.query(DocumentSegment).filter(
-            DocumentSegment.dataset_id == self.dataset.id,
-            DocumentSegment.document_id == document_id
-        ).all()
+        lock_name = 'keyword_indexing_lock_{}'.format(self.dataset.id)
+        with redis_client.lock(lock_name, timeout=600):
+            # get segment ids by document_id
+            segments = db.session.query(DocumentSegment).filter(
+                DocumentSegment.dataset_id == self.dataset.id,
+                DocumentSegment.document_id == document_id
+            ).all()
 
-        ids = [segment.index_node_id for segment in segments]
+            ids = [segment.index_node_id for segment in segments]
 
-        keyword_table = self._get_dataset_keyword_table()
-        keyword_table = self._delete_ids_from_keyword_table(keyword_table, ids)
+            keyword_table = self._get_dataset_keyword_table()
+            keyword_table = self._delete_ids_from_keyword_table(keyword_table, ids)
 
-        self._save_dataset_keyword_table(keyword_table)
+            self._save_dataset_keyword_table(keyword_table)
 
     def search(
             self, query: str,
@@ -106,13 +114,15 @@ class Jieba(BaseKeyword):
         return documents
 
     def delete(self) -> None:
-        dataset_keyword_table = self.dataset.dataset_keyword_table
-        if dataset_keyword_table:
-            db.session.delete(dataset_keyword_table)
-            db.session.commit()
-            if dataset_keyword_table.data_source_type != 'database':
-                file_key = 'keyword_files/' + self.dataset.tenant_id + '/' + self.dataset.id + '.txt'
-                storage.delete(file_key)
+        lock_name = 'keyword_indexing_lock_{}'.format(self.dataset.id)
+        with redis_client.lock(lock_name, timeout=600):
+            dataset_keyword_table = self.dataset.dataset_keyword_table
+            if dataset_keyword_table:
+                db.session.delete(dataset_keyword_table)
+                db.session.commit()
+                if dataset_keyword_table.data_source_type != 'database':
+                    file_key = 'keyword_files/' + self.dataset.tenant_id + '/' + self.dataset.id + '.txt'
+                    storage.delete(file_key)
 
     def _save_dataset_keyword_table(self, keyword_table):
         keyword_table_dict = {
@@ -135,33 +145,31 @@ class Jieba(BaseKeyword):
             storage.save(file_key, json.dumps(keyword_table_dict, cls=SetEncoder).encode('utf-8'))
 
     def _get_dataset_keyword_table(self) -> Optional[dict]:
-        lock_name = 'keyword_indexing_lock_{}'.format(self.dataset.id)
-        with redis_client.lock(lock_name, timeout=20):
-            dataset_keyword_table = self.dataset.dataset_keyword_table
-            if dataset_keyword_table:
-                keyword_table_dict = dataset_keyword_table.keyword_table_dict
-                if keyword_table_dict:
-                    return keyword_table_dict['__data__']['table']
-            else:
-                keyword_data_source_type = current_app.config['KEYWORD_DATA_SOURCE_TYPE']
-                dataset_keyword_table = DatasetKeywordTable(
-                    dataset_id=self.dataset.id,
-                    keyword_table='',
-                    data_source_type=keyword_data_source_type,
-                )
-                if keyword_data_source_type == 'database':
-                    dataset_keyword_table.keyword_table = json.dumps({
-                        '__type__': 'keyword_table',
-                        '__data__': {
-                            "index_id": self.dataset.id,
-                            "summary": None,
-                            "table": {}
-                        }
-                    }, cls=SetEncoder)
-                db.session.add(dataset_keyword_table)
-                db.session.commit()
+        dataset_keyword_table = self.dataset.dataset_keyword_table
+        if dataset_keyword_table:
+            keyword_table_dict = dataset_keyword_table.keyword_table_dict
+            if keyword_table_dict:
+                return keyword_table_dict['__data__']['table']
+        else:
+            keyword_data_source_type = current_app.config['KEYWORD_DATA_SOURCE_TYPE']
+            dataset_keyword_table = DatasetKeywordTable(
+                dataset_id=self.dataset.id,
+                keyword_table='',
+                data_source_type=keyword_data_source_type,
+            )
+            if keyword_data_source_type == 'database':
+                dataset_keyword_table.keyword_table = json.dumps({
+                    '__type__': 'keyword_table',
+                    '__data__': {
+                        "index_id": self.dataset.id,
+                        "summary": None,
+                        "table": {}
+                    }
+                }, cls=SetEncoder)
+            db.session.add(dataset_keyword_table)
+            db.session.commit()
 
-            return {}
+        return {}
 
     def _add_text_to_keyword_table(self, keyword_table: dict, id: str, keywords: list[str]) -> dict:
         for keyword in keywords:

api/core/rag/datasource/vdb/milvus/milvus_vector.py

@@ -20,16 +20,17 @@ class MilvusConfig(BaseModel):
     password: str
     secure: bool = False
     batch_size: int = 100
+    database: str = "default"
 
     @root_validator()
     def validate_config(cls, values: dict) -> dict:
-        if not values['host']:
+        if not values.get('host'):
             raise ValueError("config MILVUS_HOST is required")
-        if not values['port']:
+        if not values.get('port'):
             raise ValueError("config MILVUS_PORT is required")
-        if not values['user']:
+        if not values.get('user'):
             raise ValueError("config MILVUS_USER is required")
-        if not values['password']:
+        if not values.get('password'):
             raise ValueError("config MILVUS_PASSWORD is required")
         return values
 
@@ -39,7 +40,8 @@ class MilvusConfig(BaseModel):
             'port': self.port,
             'user': self.user,
             'password': self.password,
-            'secure': self.secure
+            'secure': self.secure,
+            'db_name': self.database,
         }
 
 
@@ -128,7 +130,8 @@ class MilvusVector(BaseVector):
             uri = "https://" + str(self._client_config.host) + ":" + str(self._client_config.port)
         else:
             uri = "http://" + str(self._client_config.host) + ":" + str(self._client_config.port)
-        connections.connect(alias=alias, uri=uri, user=self._client_config.user, password=self._client_config.password)
+        connections.connect(alias=alias, uri=uri, user=self._client_config.user, password=self._client_config.password,
+                            db_name=self._client_config.database)
 
         from pymilvus import utility
         if utility.has_collection(self._collection_name, using=alias):
@@ -140,7 +143,8 @@ class MilvusVector(BaseVector):
             uri = "https://" + str(self._client_config.host) + ":" + str(self._client_config.port)
         else:
             uri = "http://" + str(self._client_config.host) + ":" + str(self._client_config.port)
-        connections.connect(alias=alias, uri=uri, user=self._client_config.user, password=self._client_config.password)
+        connections.connect(alias=alias, uri=uri, user=self._client_config.user, password=self._client_config.password,
+                            db_name=self._client_config.database)
 
         from pymilvus import utility
         if not utility.has_collection(self._collection_name, using=alias):
@@ -192,7 +196,7 @@ class MilvusVector(BaseVector):
             else:
                 uri = "http://" + str(self._client_config.host) + ":" + str(self._client_config.port)
             connections.connect(alias=alias, uri=uri, user=self._client_config.user,
-                                password=self._client_config.password)
+                                password=self._client_config.password, db_name=self._client_config.database)
             if not utility.has_collection(self._collection_name, using=alias):
                 from pymilvus import CollectionSchema, DataType, FieldSchema
                 from pymilvus.orm.types import infer_dtype_bydata

api/core/rag/datasource/vdb/vector_factory.py

@@ -110,6 +110,7 @@ class Vector:
                     user=config.get('MILVUS_USER'),
                     password=config.get('MILVUS_PASSWORD'),
                     secure=config.get('MILVUS_SECURE'),
+                    database=config.get('MILVUS_DATABASE'),
                 )
             )
         else:

api/core/tools/provider/builtin/arxiv/tools/arxiv_search.py

@@ -1,11 +1,92 @@
-from typing import Any
+import logging
+from typing import Any, Optional
 
-from langchain.utilities import ArxivAPIWrapper
+import arxiv
 from pydantic import BaseModel, Field
 
 from core.tools.entities.tool_entities import ToolInvokeMessage
 from core.tools.tool.builtin_tool import BuiltinTool
 
+logger = logging.getLogger(__name__)
+class ArxivAPIWrapper(BaseModel):
+    """Wrapper around ArxivAPI.
+
+    To use, you should have the ``arxiv`` python package installed.
+    https://lukasschwab.me/arxiv.py/index.html
+    This wrapper will use the Arxiv API to conduct searches and
+    fetch document summaries. By default, it will return the document summaries
+    of the top-k results.
+    It limits the Document content by doc_content_chars_max.
+    Set doc_content_chars_max=None if you don't want to limit the content size.
+
+    Args:
+        top_k_results: number of the top-scored document used for the arxiv tool
+        ARXIV_MAX_QUERY_LENGTH: the cut limit on the query used for the arxiv tool.
+        load_max_docs: a limit to the number of loaded documents
+        load_all_available_meta:
+            if True: the `metadata` of the loaded Documents contains all available
+            meta info (see https://lukasschwab.me/arxiv.py/index.html#Result),
+            if False: the `metadata` contains only the published date, title,
+            authors and summary.
+        doc_content_chars_max: an optional cut limit for the length of a document's
+            content
+
+    Example:
+        .. code-block:: python
+
+            arxiv = ArxivAPIWrapper(
+                top_k_results = 3,
+                ARXIV_MAX_QUERY_LENGTH = 300,
+                load_max_docs = 3,
+                load_all_available_meta = False,
+                doc_content_chars_max = 40000
+            )
+            arxiv.run("tree of thought llm)
+    """
+
+    arxiv_search = arxiv.Search  #: :meta private:
+    arxiv_exceptions = (
+        arxiv.ArxivError,
+        arxiv.UnexpectedEmptyPageError,
+        arxiv.HTTPError,
+    )  # :meta private:
+    top_k_results: int = 3
+    ARXIV_MAX_QUERY_LENGTH = 300
+    load_max_docs: int = 100
+    load_all_available_meta: bool = False
+    doc_content_chars_max: Optional[int] = 4000
+
+    def run(self, query: str) -> str:
+        """
+        Performs an arxiv search and A single string
+        with the publish date, title, authors, and summary
+        for each article separated by two newlines.
+
+        If an error occurs or no documents found, error text
+        is returned instead. Wrapper for
+        https://lukasschwab.me/arxiv.py/index.html#Search
+
+        Args:
+            query: a plaintext search query
+        """  # noqa: E501
+        try:
+            results = self.arxiv_search(  # type: ignore
+                query[: self.ARXIV_MAX_QUERY_LENGTH], max_results=self.top_k_results
+            ).results()
+        except self.arxiv_exceptions as ex:
+            return f"Arxiv exception: {ex}"
+        docs = [
+            f"Published: {result.updated.date()}\n"
+            f"Title: {result.title}\n"
+            f"Authors: {', '.join(a.name for a in result.authors)}\n"
+            f"Summary: {result.summary}"
+            for result in results
+        ]
+        if docs:
+            return "\n\n".join(docs)[: self.doc_content_chars_max]
+        else:
+            return "No good Arxiv Result was found"
+
 
 class ArxivSearchInput(BaseModel):
     query: str = Field(..., description="Search query.")

api/core/tools/provider/builtin/brave/tools/brave_search.py

@@ -1,11 +1,95 @@
-from typing import Any
+import json
+from typing import Any, Optional
 
-from langchain.tools import BraveSearch
+import requests
+from pydantic import BaseModel, Field
 
 from core.tools.entities.tool_entities import ToolInvokeMessage
 from core.tools.tool.builtin_tool import BuiltinTool
 
 
+class BraveSearchWrapper(BaseModel):
+    """Wrapper around the Brave search engine."""
+
+    api_key: str
+    """The API key to use for the Brave search engine."""
+    search_kwargs: dict = Field(default_factory=dict)
+    """Additional keyword arguments to pass to the search request."""
+    base_url = "https://api.search.brave.com/res/v1/web/search"
+    """The base URL for the Brave search engine."""
+
+    def run(self, query: str) -> str:
+        """Query the Brave search engine and return the results as a JSON string.
+
+        Args:
+            query: The query to search for.
+
+        Returns: The results as a JSON string.
+
+        """
+        web_search_results = self._search_request(query=query)
+        final_results = [
+            {
+                "title": item.get("title"),
+                "link": item.get("url"),
+                "snippet": item.get("description"),
+            }
+            for item in web_search_results
+        ]
+        return json.dumps(final_results)
+    
+    def _search_request(self, query: str) -> list[dict]:
+        headers = {
+            "X-Subscription-Token": self.api_key,
+            "Accept": "application/json",
+        }
+        req = requests.PreparedRequest()
+        params = {**self.search_kwargs, **{"q": query}}
+        req.prepare_url(self.base_url, params)
+        if req.url is None:
+            raise ValueError("prepared url is None, this should not happen")
+
+        response = requests.get(req.url, headers=headers)
+        if not response.ok:
+            raise Exception(f"HTTP error {response.status_code}")
+
+        return response.json().get("web", {}).get("results", [])
+
+class BraveSearch(BaseModel):
+    """Tool that queries the BraveSearch."""
+
+    name = "brave_search"
+    description = (
+        "a search engine. "
+        "useful for when you need to answer questions about current events."
+        " input should be a search query."
+    )
+    search_wrapper: BraveSearchWrapper
+
+    @classmethod
+    def from_api_key(
+        cls, api_key: str, search_kwargs: Optional[dict] = None, **kwargs: Any
+    ) -> "BraveSearch":
+        """Create a tool from an api key.
+
+        Args:
+            api_key: The api key to use.
+            search_kwargs: Any additional kwargs to pass to the search wrapper.
+            **kwargs: Any additional kwargs to pass to the tool.
+
+        Returns:
+            A tool.
+        """
+        wrapper = BraveSearchWrapper(api_key=api_key, search_kwargs=search_kwargs or {})
+        return cls(search_wrapper=wrapper, **kwargs)
+
+    def _run(
+        self,
+        query: str,
+    ) -> str:
+        """Use the tool."""
+        return self.search_wrapper.run(query)
+
 class BraveSearchTool(BuiltinTool):
     """
     Tool for performing a search using Brave search engine.
@@ -31,7 +115,7 @@ class BraveSearchTool(BuiltinTool):
 
         tool = BraveSearch.from_api_key(api_key=api_key, search_kwargs={"count": count})
 
-        results = tool.run(query)
+        results = tool._run(query)
 
         if not results:
             return self.create_text_message(f"No results found for '{query}' in Tavily")

api/core/tools/provider/builtin/duckduckgo/tools/duckduckgo_search.py

@@ -1,16 +1,147 @@
-from typing import Any
+from typing import Any, Optional
 
-from langchain.tools import DuckDuckGoSearchRun
 from pydantic import BaseModel, Field
 
 from core.tools.entities.tool_entities import ToolInvokeMessage
 from core.tools.tool.builtin_tool import BuiltinTool
 
 
+class DuckDuckGoSearchAPIWrapper(BaseModel):
+    """Wrapper for DuckDuckGo Search API.
+
+    Free and does not require any setup.
+    """
+
+    region: Optional[str] = "wt-wt"
+    safesearch: str = "moderate"
+    time: Optional[str] = "y"
+    max_results: int = 5
+
+    def get_snippets(self, query: str) -> list[str]:
+        """Run query through DuckDuckGo and return concatenated results."""
+        from duckduckgo_search import DDGS
+
+        with DDGS() as ddgs:
+            results = ddgs.text(
+                query,
+                region=self.region,
+                safesearch=self.safesearch,
+                timelimit=self.time,
+            )
+            if results is None:
+                return ["No good DuckDuckGo Search Result was found"]
+            snippets = []
+            for i, res in enumerate(results, 1):
+                if res is not None:
+                    snippets.append(res["body"])
+                if len(snippets) == self.max_results:
+                    break
+        return snippets
+
+    def run(self, query: str) -> str:
+        snippets = self.get_snippets(query)
+        return " ".join(snippets)
+
+    def results(
+        self, query: str, num_results: int, backend: str = "api"
+    ) -> list[dict[str, str]]:
+        """Run query through DuckDuckGo and return metadata.
+
+        Args:
+            query: The query to search for.
+            num_results: The number of results to return.
+
+        Returns:
+            A list of dictionaries with the following keys:
+                snippet - The description of the result.
+                title - The title of the result.
+                link - The link to the result.
+        """
+        from duckduckgo_search import DDGS
+
+        with DDGS() as ddgs:
+            results = ddgs.text(
+                query,
+                region=self.region,
+                safesearch=self.safesearch,
+                timelimit=self.time,
+                backend=backend,
+            )
+            if results is None:
+                return [{"Result": "No good DuckDuckGo Search Result was found"}]
+
+            def to_metadata(result: dict) -> dict[str, str]:
+                if backend == "news":
+                    return {
+                        "date": result["date"],
+                        "title": result["title"],
+                        "snippet": result["body"],
+                        "source": result["source"],
+                        "link": result["url"],
+                    }
+                return {
+                    "snippet": result["body"],
+                    "title": result["title"],
+                    "link": result["href"],
+                }
+
+            formatted_results = []
+            for i, res in enumerate(results, 1):
+                if res is not None:
+                    formatted_results.append(to_metadata(res))
+                if len(formatted_results) == num_results:
+                    break
+        return formatted_results
+
+
+class DuckDuckGoSearchRun(BaseModel):
+    """Tool that queries the DuckDuckGo search API."""
+
+    name = "duckduckgo_search"
+    description = (
+        "A wrapper around DuckDuckGo Search. "
+        "Useful for when you need to answer questions about current events. "
+        "Input should be a search query."
+    )
+    api_wrapper: DuckDuckGoSearchAPIWrapper = Field(
+        default_factory=DuckDuckGoSearchAPIWrapper
+    )
+
+    def _run(
+        self,
+        query: str,
+    ) -> str:
+        """Use the tool."""
+        return self.api_wrapper.run(query)
+
+
+class DuckDuckGoSearchResults(BaseModel):
+    """Tool that queries the DuckDuckGo search API and gets back json."""
+
+    name = "DuckDuckGo Results JSON"
+    description = (
+        "A wrapper around Duck Duck Go Search. "
+        "Useful for when you need to answer questions about current events. "
+        "Input should be a search query. Output is a JSON array of the query results"
+    )
+    num_results: int = 4
+    api_wrapper: DuckDuckGoSearchAPIWrapper = Field(
+        default_factory=DuckDuckGoSearchAPIWrapper
+    )
+    backend: str = "api"
+
+    def _run(
+        self,
+        query: str,
+    ) -> str:
+        """Use the tool."""
+        res = self.api_wrapper.results(query, self.num_results, backend=self.backend)
+        res_strs = [", ".join([f"{k}: {v}" for k, v in d.items()]) for d in res]
+        return ", ".join([f"[{rs}]" for rs in res_strs])
+
 class DuckDuckGoInput(BaseModel):
     query: str = Field(..., description="Search query.")
 
-
 class DuckDuckGoSearchTool(BuiltinTool):
     """
     Tool for performing a search using DuckDuckGo search engine.
@@ -34,7 +165,7 @@ class DuckDuckGoSearchTool(BuiltinTool):
 
         tool = DuckDuckGoSearchRun(args_schema=DuckDuckGoInput)
 
-        result = tool.run(query)
+        result = tool._run(query)
 
         return self.create_text_message(self.summary(user_id=user_id, content=result))
     

api/core/tools/provider/builtin/google/tools/google_search.py

@@ -70,43 +70,44 @@ class SerpAPI:
             raise ValueError(f"Got error from SerpAPI: {res['error']}")
         
         if typ == "text":
+            toret = ""
             if "answer_box" in res.keys() and type(res["answer_box"]) == list:
-                res["answer_box"] = res["answer_box"][0]
+                res["answer_box"] = res["answer_box"][0] + "\n"
             if "answer_box" in res.keys() and "answer" in res["answer_box"].keys():
-                toret = res["answer_box"]["answer"]
-            elif "answer_box" in res.keys() and "snippet" in res["answer_box"].keys():
-                toret = res["answer_box"]["snippet"]
-            elif (
+                toret += res["answer_box"]["answer"] + "\n"
+            if "answer_box" in res.keys() and "snippet" in res["answer_box"].keys():
+                toret += res["answer_box"]["snippet"] + "\n"
+            if (
                 "answer_box" in res.keys()
                 and "snippet_highlighted_words" in res["answer_box"].keys()
             ):
-                toret = res["answer_box"]["snippet_highlighted_words"][0]
-            elif (
+                for item in res["answer_box"]["snippet_highlighted_words"]:
+                    toret += item + "\n"
+            if (
                 "sports_results" in res.keys()
                 and "game_spotlight" in res["sports_results"].keys()
             ):
-                toret = res["sports_results"]["game_spotlight"]
-            elif (
+                toret += res["sports_results"]["game_spotlight"] + "\n"
+            if (
                 "shopping_results" in res.keys()
                 and "title" in res["shopping_results"][0].keys()
             ):
-                toret = res["shopping_results"][:3]
-            elif (
+                toret += res["shopping_results"][:3] + "\n"
+            if (
                 "knowledge_graph" in res.keys()
                 and "description" in res["knowledge_graph"].keys()
             ):
-                toret = res["knowledge_graph"]["description"]
-            elif "snippet" in res["organic_results"][0].keys():
-                toret = res["organic_results"][0]["snippet"]
-            elif "link" in res["organic_results"][0].keys():
-                toret = res["organic_results"][0]["link"]
-            elif (
+                toret = res["knowledge_graph"]["description"] + "\n"
+            if "snippet" in res["organic_results"][0].keys():
+                for item in res["organic_results"]:
+                    toret += "content: " + item["snippet"] + "\n" + "link: " + item["link"] + "\n"
+            if (
                 "images_results" in res.keys()
                 and "thumbnail" in res["images_results"][0].keys()
             ):
                 thumbnails = [item["thumbnail"] for item in res["images_results"][:10]]
                 toret = thumbnails
-            else:
+            if toret == "":
                 toret = "No good search result found"
         elif typ == "link":
             if "knowledge_graph" in res.keys() and "title" in res["knowledge_graph"].keys() \

api/core/tools/provider/builtin/pubmed/tools/pubmed_search.py

@@ -1,16 +1,187 @@
+import json
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
 from typing import Any
 
-from langchain.tools import PubmedQueryRun
 from pydantic import BaseModel, Field
 
 from core.tools.entities.tool_entities import ToolInvokeMessage
 from core.tools.tool.builtin_tool import BuiltinTool
 
 
+class PubMedAPIWrapper(BaseModel):
+    """
+    Wrapper around PubMed API.
+
+    This wrapper will use the PubMed API to conduct searches and fetch
+    document summaries. By default, it will return the document summaries
+    of the top-k results of an input search.
+
+    Parameters:
+        top_k_results: number of the top-scored document used for the PubMed tool
+        load_max_docs: a limit to the number of loaded documents
+        load_all_available_meta:
+          if True: the `metadata` of the loaded Documents gets all available meta info
+            (see https://www.ncbi.nlm.nih.gov/books/NBK25499/#chapter4.ESearch)
+          if False: the `metadata` gets only the most informative fields.
+    """
+
+    base_url_esearch = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?"
+    base_url_efetch = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?"
+    max_retry = 5
+    sleep_time = 0.2
+
+    # Default values for the parameters
+    top_k_results: int = 3
+    load_max_docs: int = 25
+    ARXIV_MAX_QUERY_LENGTH = 300
+    doc_content_chars_max: int = 2000
+    load_all_available_meta: bool = False
+    email: str = "your_email@example.com"
+
+    def run(self, query: str) -> str:
+        """
+        Run PubMed search and get the article meta information.
+        See https://www.ncbi.nlm.nih.gov/books/NBK25499/#chapter4.ESearch
+        It uses only the most informative fields of article meta information.
+        """
+
+        try:
+            # Retrieve the top-k results for the query
+            docs = [
+                f"Published: {result['pub_date']}\nTitle: {result['title']}\n"
+                f"Summary: {result['summary']}"
+                for result in self.load(query[: self.ARXIV_MAX_QUERY_LENGTH])
+            ]
+
+            # Join the results and limit the character count
+            return (
+                "\n\n".join(docs)[:self.doc_content_chars_max]
+                if docs
+                else "No good PubMed Result was found"
+            )
+        except Exception as ex:
+            return f"PubMed exception: {ex}"
+
+    def load(self, query: str) -> list[dict]:
+        """
+        Search PubMed for documents matching the query.
+        Return a list of dictionaries containing the document metadata.
+        """
+
+        url = (
+            self.base_url_esearch
+            + "db=pubmed&term="
+            + str({urllib.parse.quote(query)})
+            + f"&retmode=json&retmax={self.top_k_results}&usehistory=y"
+        )
+        result = urllib.request.urlopen(url)
+        text = result.read().decode("utf-8")
+        json_text = json.loads(text)
+
+        articles = []
+        webenv = json_text["esearchresult"]["webenv"]
+        for uid in json_text["esearchresult"]["idlist"]:
+            article = self.retrieve_article(uid, webenv)
+            articles.append(article)
+
+        # Convert the list of articles to a JSON string
+        return articles
+
+    def retrieve_article(self, uid: str, webenv: str) -> dict:
+        url = (
+            self.base_url_efetch
+            + "db=pubmed&retmode=xml&id="
+            + uid
+            + "&webenv="
+            + webenv
+        )
+
+        retry = 0
+        while True:
+            try:
+                result = urllib.request.urlopen(url)
+                break
+            except urllib.error.HTTPError as e:
+                if e.code == 429 and retry < self.max_retry:
+                    # Too Many Requests error
+                    # wait for an exponentially increasing amount of time
+                    print(
+                        f"Too Many Requests, "
+                        f"waiting for {self.sleep_time:.2f} seconds..."
+                    )
+                    time.sleep(self.sleep_time)
+                    self.sleep_time *= 2
+                    retry += 1
+                else:
+                    raise e
+
+        xml_text = result.read().decode("utf-8")
+
+        # Get title
+        title = ""
+        if "<ArticleTitle>" in xml_text and "</ArticleTitle>" in xml_text:
+            start_tag = "<ArticleTitle>"
+            end_tag = "</ArticleTitle>"
+            title = xml_text[
+                xml_text.index(start_tag) + len(start_tag) : xml_text.index(end_tag)
+            ]
+
+        # Get abstract
+        abstract = ""
+        if "<AbstractText>" in xml_text and "</AbstractText>" in xml_text:
+            start_tag = "<AbstractText>"
+            end_tag = "</AbstractText>"
+            abstract = xml_text[
+                xml_text.index(start_tag) + len(start_tag) : xml_text.index(end_tag)
+            ]
+
+        # Get publication date
+        pub_date = ""
+        if "<PubDate>" in xml_text and "</PubDate>" in xml_text:
+            start_tag = "<PubDate>"
+            end_tag = "</PubDate>"
+            pub_date = xml_text[
+                xml_text.index(start_tag) + len(start_tag) : xml_text.index(end_tag)
+            ]
+
+        # Return article as dictionary
+        article = {
+            "uid": uid,
+            "title": title,
+            "summary": abstract,
+            "pub_date": pub_date,
+        }
+        return article
+
+
+class PubmedQueryRun(BaseModel):
+    """Tool that searches the PubMed API."""
+
+    name = "PubMed"
+    description = (
+        "A wrapper around PubMed.org "
+        "Useful for when you need to answer questions about Physics, Mathematics, "
+        "Computer Science, Quantitative Biology, Quantitative Finance, Statistics, "
+        "Electrical Engineering, and Economics "
+        "from scientific articles on PubMed.org. "
+        "Input should be a search query."
+    )
+    api_wrapper: PubMedAPIWrapper = Field(default_factory=PubMedAPIWrapper)
+
+    def _run(
+        self,
+        query: str,
+    ) -> str:
+        """Use the Arxiv tool."""
+        return self.api_wrapper.run(query)
+
+
 class PubMedInput(BaseModel):
     query: str = Field(..., description="Search query.")
 
-
 class PubMedSearchTool(BuiltinTool):
     """
     Tool for performing a search using PubMed search engine.
@@ -34,7 +205,7 @@ class PubMedSearchTool(BuiltinTool):
 
         tool = PubmedQueryRun(args_schema=PubMedInput)
 
-        result = tool.run(query)
+        result = tool._run(query)
 
         return self.create_text_message(self.summary(user_id=user_id, content=result))
     

api/core/tools/provider/builtin/twilio/tools/send_message.py

@@ -1,11 +1,81 @@
-from typing import Any, Union
+from typing import Any, Optional, Union
 
-from langchain.utilities import TwilioAPIWrapper
+from pydantic import BaseModel, validator
 
 from core.tools.entities.tool_entities import ToolInvokeMessage
 from core.tools.tool.builtin_tool import BuiltinTool
 
 
+class TwilioAPIWrapper(BaseModel):
+    """Messaging Client using Twilio.
+
+    To use, you should have the ``twilio`` python package installed,
+    and the environment variables ``TWILIO_ACCOUNT_SID``, ``TWILIO_AUTH_TOKEN``, and
+    ``TWILIO_FROM_NUMBER``, or pass `account_sid`, `auth_token`, and `from_number` as
+    named parameters to the constructor.
+
+    Example:
+        .. code-block:: python
+
+            from langchain.utilities.twilio import TwilioAPIWrapper
+            twilio = TwilioAPIWrapper(
+                account_sid="ACxxx",
+                auth_token="xxx",
+                from_number="+10123456789"
+            )
+            twilio.run('test', '+12484345508')
+    """
+
+    client: Any  #: :meta private:
+    account_sid: Optional[str] = None
+    """Twilio account string identifier."""
+    auth_token: Optional[str] = None
+    """Twilio auth token."""
+    from_number: Optional[str] = None
+    """A Twilio phone number in [E.164](https://www.twilio.com/docs/glossary/what-e164) 
+        format, an 
+        [alphanumeric sender ID](https://www.twilio.com/docs/sms/send-messages#use-an-alphanumeric-sender-id), 
+        or a [Channel Endpoint address](https://www.twilio.com/docs/sms/channels#channel-addresses) 
+        that is enabled for the type of message you want to send. Phone numbers or 
+        [short codes](https://www.twilio.com/docs/sms/api/short-code) purchased from 
+        Twilio also work here. You cannot, for example, spoof messages from a private 
+        cell phone number. If you are using `messaging_service_sid`, this parameter 
+        must be empty.
+    """  # noqa: E501
+
+    @validator("client", pre=True, always=True)
+    def set_validator(cls, values: dict) -> dict:
+        """Validate that api key and python package exists in environment."""
+        try:
+            from twilio.rest import Client
+        except ImportError:
+            raise ImportError(
+                "Could not import twilio python package. "
+                "Please install it with `pip install twilio`."
+            )
+        account_sid = values.get("account_sid")
+        auth_token = values.get("auth_token")
+        values["from_number"] = values.get("from_number")
+        values["client"] = Client(account_sid, auth_token)
+
+        return values
+
+    def run(self, body: str, to: str) -> str:
+        """Run body through Twilio and respond with message sid.
+
+        Args:
+            body: The text of the message you want to send. Can be up to 1,600
+                characters in length.
+            to: The destination phone number in
+                [E.164](https://www.twilio.com/docs/glossary/what-e164) format for
+                SMS/MMS or
+                [Channel user address](https://www.twilio.com/docs/sms/channels#channel-addresses)
+                for other 3rd-party channels.
+        """  # noqa: E501
+        message = self.client.messages.create(to, from_=self.from_number, body=body)
+        return message.sid
+
+
 class SendMessageTool(BuiltinTool):
     """
     A tool for sending messages using Twilio API.

api/core/tools/provider/builtin/wikipedia/tools/wikipedia_search.py

@@ -1,16 +1,79 @@
-from typing import Any, Union
+from typing import Any, Optional, Union
 
-from langchain import WikipediaAPIWrapper
-from langchain.tools import WikipediaQueryRun
-from pydantic import BaseModel, Field
+import wikipedia
 
 from core.tools.entities.tool_entities import ToolInvokeMessage
 from core.tools.tool.builtin_tool import BuiltinTool
 
+WIKIPEDIA_MAX_QUERY_LENGTH = 300
 
-class WikipediaInput(BaseModel):
-    query: str = Field(..., description="search query.")
+class WikipediaAPIWrapper:
+    """Wrapper around WikipediaAPI.
 
+    To use, you should have the ``wikipedia`` python package installed.
+    This wrapper will use the Wikipedia API to conduct searches and
+    fetch page summaries. By default, it will return the page summaries
+    of the top-k results.
+    It limits the Document content by doc_content_chars_max.
+    """
+
+    top_k_results: int = 3
+    lang: str = "en"
+    load_all_available_meta: bool = False
+    doc_content_chars_max: int = 4000
+
+    def __init__(self, doc_content_chars_max: int = 4000):
+        self.doc_content_chars_max = doc_content_chars_max
+
+    def run(self, query: str) -> str:
+        wikipedia.set_lang(self.lang)
+        wiki_client = wikipedia
+
+        """Run Wikipedia search and get page summaries."""
+        page_titles = wiki_client.search(query[:WIKIPEDIA_MAX_QUERY_LENGTH])
+        summaries = []
+        for page_title in page_titles[: self.top_k_results]:
+            if wiki_page := self._fetch_page(page_title):
+                if summary := self._formatted_page_summary(page_title, wiki_page):
+                    summaries.append(summary)
+        if not summaries:
+            return "No good Wikipedia Search Result was found"
+        return "\n\n".join(summaries)[: self.doc_content_chars_max]
+
+    @staticmethod
+    def _formatted_page_summary(page_title: str, wiki_page: Any) -> Optional[str]:
+        return f"Page: {page_title}\nSummary: {wiki_page.summary}"
+
+    def _fetch_page(self, page: str) -> Optional[str]:
+        try:
+            return wikipedia.page(title=page, auto_suggest=False)
+        except (
+            wikipedia.exceptions.PageError,
+            wikipedia.exceptions.DisambiguationError,
+        ):
+            return None
+
+class WikipediaQueryRun:
+    """Tool that searches the Wikipedia API."""
+
+    name = "Wikipedia"
+    description = (
+        "A wrapper around Wikipedia. "
+        "Useful for when you need to answer general questions about "
+        "people, places, companies, facts, historical events, or other subjects. "
+        "Input should be a search query."
+    )
+    api_wrapper: WikipediaAPIWrapper
+
+    def __init__(self, api_wrapper: WikipediaAPIWrapper):
+        self.api_wrapper = api_wrapper
+
+    def _run(
+        self,
+        query: str,
+    ) -> str:
+        """Use the Wikipedia tool."""
+        return self.api_wrapper.run(query)
 class WikiPediaSearchTool(BuiltinTool):
     def _invoke(self, 
                 user_id: str, 
@@ -24,14 +87,10 @@ class WikiPediaSearchTool(BuiltinTool):
             return self.create_text_message('Please input query')
         
         tool = WikipediaQueryRun(
-            name="wikipedia",
             api_wrapper=WikipediaAPIWrapper(doc_content_chars_max=4000),
-            args_schema=WikipediaInput
         )
 
-        result = tool.run(tool_input={
-            'query': query
-        })
+        result = tool._run(query)
 
         return self.create_text_message(self.summary(user_id=user_id,content=result))
     

api/core/workflow/nodes/code/code_node.py

@@ -234,6 +234,9 @@ class CodeNode(BaseNode):
         parameters_validated = {}
         for output_name, output_config in output_schema.items():
             dot = '.' if prefix else ''
+            if output_name not in result:
+                raise ValueError(f'Output {prefix}{dot}{output_name} is missing.')
+            
             if output_config.type == 'object':
                 # check if output is object
                 if not isinstance(result.get(output_name), dict):

api/core/workflow/nodes/knowledge_retrieval/knowledge_retrieval_node.py

@@ -242,7 +242,10 @@ class KnowledgeRetrievalNode(BaseNode):
                 # get top k
                 top_k = retrieval_model_config['top_k']
                 # get retrieval method
-                retrival_method = retrieval_model_config['search_method']
+                if dataset.indexing_technique == "economy":
+                    retrival_method = 'keyword_search'
+                else:
+                    retrival_method = retrieval_model_config['search_method']
                 # get reranking model
                 reranking_model=retrieval_model_config['reranking_model'] \
                     if retrieval_model_config['reranking_enable'] else None

api/core/workflow/nodes/question_classifier/question_classifier_node.py

@@ -13,7 +13,7 @@ from core.prompt.entities.advanced_prompt_entities import ChatModelMessage, Comp
 from core.prompt.simple_prompt_transform import ModelMode
 from core.prompt.utils.prompt_message_util import PromptMessageUtil
 from core.workflow.entities.base_node_data_entities import BaseNodeData
-from core.workflow.entities.node_entities import NodeRunResult, NodeType
+from core.workflow.entities.node_entities import NodeRunMetadataKey, NodeRunResult, NodeType
 from core.workflow.entities.variable_pool import VariablePool
 from core.workflow.nodes.llm.llm_node import LLMNode
 from core.workflow.nodes.question_classifier.entities import QuestionClassifierNodeData
@@ -65,7 +65,9 @@ class QuestionClassifierNode(LLMNode):
         categories = [_class.name for _class in node_data.classes]
         try:
             result_text_json = json.loads(result_text.strip('```JSON\n'))
-            categories = result_text_json.get('categories', [])
+            categories_result = result_text_json.get('categories', [])
+            if categories_result:
+                categories = categories_result
         except Exception:
             logging.error(f"Failed to parse result text: {result_text}")
         try:
@@ -89,14 +91,24 @@ class QuestionClassifierNode(LLMNode):
                 inputs=variables,
                 process_data=process_data,
                 outputs=outputs,
-                edge_source_handle=classes_map.get(categories[0], None)
+                edge_source_handle=classes_map.get(categories[0], None),
+                metadata={
+                    NodeRunMetadataKey.TOTAL_TOKENS: usage.total_tokens,
+                    NodeRunMetadataKey.TOTAL_PRICE: usage.total_price,
+                    NodeRunMetadataKey.CURRENCY: usage.currency
+                }
             )
 
         except ValueError as e:
             return NodeRunResult(
                 status=WorkflowNodeExecutionStatus.FAILED,
                 inputs=variables,
-                error=str(e)
+                error=str(e),
+                metadata={
+                    NodeRunMetadataKey.TOTAL_TOKENS: usage.total_tokens,
+                    NodeRunMetadataKey.TOTAL_PRICE: usage.total_price,
+                    NodeRunMetadataKey.CURRENCY: usage.currency
+                }
             )
 
     @classmethod

api/core/workflow/workflow_engine_manager.py

@@ -1,9 +1,10 @@
 import logging
 import time
-from typing import Optional
+from typing import Optional, cast
 
+from core.app.app_config.entities import FileExtraConfig
 from core.app.apps.base_app_queue_manager import GenerateTaskStoppedException
-from core.file.file_obj import FileVar
+from core.file.file_obj import FileTransferMethod, FileType, FileVar
 from core.workflow.callbacks.base_workflow_callback import BaseWorkflowCallback
 from core.workflow.entities.node_entities import NodeRunMetadataKey, NodeRunResult, NodeType
 from core.workflow.entities.variable_pool import VariablePool, VariableValue
@@ -16,6 +17,7 @@ from core.workflow.nodes.end.end_node import EndNode
 from core.workflow.nodes.http_request.http_request_node import HttpRequestNode
 from core.workflow.nodes.if_else.if_else_node import IfElseNode
 from core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node import KnowledgeRetrievalNode
+from core.workflow.nodes.llm.entities import LLMNodeData
 from core.workflow.nodes.llm.llm_node import LLMNode
 from core.workflow.nodes.question_classifier.question_classifier_node import QuestionClassifierNode
 from core.workflow.nodes.start.start_node import StartNode
@@ -219,7 +221,8 @@ class WorkflowEngineManager:
             raise ValueError('node id not found in workflow graph')
 
         # Get node class
-        node_cls = node_classes.get(NodeType.value_of(node_config.get('data', {}).get('type')))
+        node_type = NodeType.value_of(node_config.get('data', {}).get('type'))
+        node_cls = node_classes.get(node_type)
 
         # init workflow run state
         node_instance = node_cls(
@@ -252,11 +255,40 @@ class WorkflowEngineManager:
                 variable_node_id = variable_selector[0]
                 variable_key_list = variable_selector[1:]
 
+                # get value
+                value = user_inputs.get(variable_key)
+
+                # temp fix for image type
+                if node_type == NodeType.LLM:
+                    new_value = []
+                    if isinstance(value, list):
+                        node_data = node_instance.node_data
+                        node_data = cast(LLMNodeData, node_data)
+
+                        detail = node_data.vision.configs.detail if node_data.vision.configs else None
+
+                        for item in value:
+                            if isinstance(item, dict) and 'type' in item and item['type'] == 'image':
+                                transfer_method = FileTransferMethod.value_of(item.get('transfer_method'))
+                                file = FileVar(
+                                    tenant_id=workflow.tenant_id,
+                                    type=FileType.IMAGE,
+                                    transfer_method=transfer_method,
+                                    url=item.get('url') if transfer_method == FileTransferMethod.REMOTE_URL else None,
+                                    related_id=item.get(
+                                        'upload_file_id') if transfer_method == FileTransferMethod.LOCAL_FILE else None,
+                                    extra_config=FileExtraConfig(image_config={'detail': detail} if detail else None),
+                                )
+                                new_value.append(file)
+
+                    if new_value:
+                        value = new_value
+
                 # append variable and value to variable pool
                 variable_pool.append_variable(
                     node_id=variable_node_id,
                     variable_key_list=variable_key_list,
-                    value=user_inputs.get(variable_key)
+                    value=value
                 )
             # run node
             node_run_result = node_instance.run(

api/extensions/ext_celery.py

@@ -28,6 +28,7 @@ def init_app(app: Flask) -> Celery:
 
     celery_app.conf.update(
         result_backend=app.config["CELERY_RESULT_BACKEND"],
+        broker_connection_retry_on_startup=True,
     )
 
     if app.config["BROKER_USE_SSL"]:

api/models/model.py

@@ -815,7 +815,7 @@ class Message(db.Model):
     @property
     def workflow_run(self):
         if self.workflow_run_id:
-            from api.models.workflow import WorkflowRun
+            from .workflow import WorkflowRun
             return db.session.query(WorkflowRun).filter(WorkflowRun.id == self.workflow_run_id).first()
 
         return None

api/models/workflow.py

@@ -299,6 +299,10 @@ class WorkflowRun(db.Model):
             Message.workflow_run_id == self.id
         ).first()
 
+    @property
+    def workflow(self):
+        return db.session.query(Workflow).filter(Workflow.id == self.workflow_id).first()
+
 
 class WorkflowNodeExecutionTriggeredFrom(Enum):
     """

api/services/conversation_service.py

@@ -1,5 +1,8 @@
 from typing import Optional, Union
 
+from sqlalchemy import or_
+
+from core.app.entities.app_invoke_entities import InvokeFrom
 from core.llm_generator.llm_generator import LLMGenerator
 from extensions.ext_database import db
 from libs.infinite_scroll_pagination import InfiniteScrollPagination
@@ -13,8 +16,9 @@ class ConversationService:
     @classmethod
     def pagination_by_last_id(cls, app_model: App, user: Optional[Union[Account, EndUser]],
                               last_id: Optional[str], limit: int,
-                              include_ids: Optional[list] = None, exclude_ids: Optional[list] = None,
-                              exclude_debug_conversation: bool = False) -> InfiniteScrollPagination:
+                              invoke_from: InvokeFrom,
+                              include_ids: Optional[list] = None,
+                              exclude_ids: Optional[list] = None) -> InfiniteScrollPagination:
         if not user:
             return InfiniteScrollPagination(data=[], limit=limit, has_more=False)
 
@@ -24,6 +28,7 @@ class ConversationService:
             Conversation.from_source == ('api' if isinstance(user, EndUser) else 'console'),
             Conversation.from_end_user_id == (user.id if isinstance(user, EndUser) else None),
             Conversation.from_account_id == (user.id if isinstance(user, Account) else None),
+            or_(Conversation.invoke_from.is_(None), Conversation.invoke_from == invoke_from.value)
         )
 
         if include_ids is not None:
@@ -32,9 +37,6 @@ class ConversationService:
         if exclude_ids is not None:
             base_query = base_query.filter(~Conversation.id.in_(exclude_ids))
 
-        if exclude_debug_conversation:
-            base_query = base_query.filter(Conversation.override_model_configs == None)
-
         if last_id:
             last_conversation = base_query.filter(
                 Conversation.id == last_id,

api/services/web_conversation_service.py

@@ -1,5 +1,6 @@
 from typing import Optional, Union
 
+from core.app.entities.app_invoke_entities import InvokeFrom
 from extensions.ext_database import db
 from libs.infinite_scroll_pagination import InfiniteScrollPagination
 from models.account import Account
@@ -11,8 +12,8 @@ from services.conversation_service import ConversationService
 class WebConversationService:
     @classmethod
     def pagination_by_last_id(cls, app_model: App, user: Optional[Union[Account, EndUser]],
-                              last_id: Optional[str], limit: int, pinned: Optional[bool] = None,
-                              exclude_debug_conversation: bool = False) -> InfiniteScrollPagination:
+                              last_id: Optional[str], limit: int, invoke_from: InvokeFrom,
+                              pinned: Optional[bool] = None) -> InfiniteScrollPagination:
         include_ids = None
         exclude_ids = None
         if pinned is not None:
@@ -32,9 +33,9 @@ class WebConversationService:
             user=user,
             last_id=last_id,
             limit=limit,
+            invoke_from=invoke_from,
             include_ids=include_ids,
             exclude_ids=exclude_ids,
-            exclude_debug_conversation=exclude_debug_conversation
         )
 
     @classmethod

api/tests/unittests/test_model.py

@@ -0,0 +1,24 @@
+import pytest
+from pydantic.error_wrappers import ValidationError
+
+from core.rag.datasource.vdb.milvus.milvus_vector import MilvusConfig
+
+
+def test_default_value():
+    valid_config = {
+        'host': 'localhost',
+        'port': 19530,
+        'user': 'root',
+        'password': 'Milvus'
+    }
+
+    for key in valid_config:
+        config = valid_config.copy()
+        del config[key]
+        with pytest.raises(ValidationError) as e:
+            MilvusConfig(**config)
+        assert e.value.errors()[1]['msg'] == f'config MILVUS_{key.upper()} is required'
+    
+    config = MilvusConfig(**valid_config)
+    assert config.secure is False
+    assert config.database == 'default'

docker/docker-compose.yaml

@@ -2,7 +2,7 @@ version: '3'
 services:
   # API service
   api:
-    image: langgenius/dify-api:0.6.0-fix1
+    image: langgenius/dify-api:0.6.1
     restart: always
     environment:
       # Startup mode, 'api' starts the API server.
@@ -150,7 +150,7 @@ services:
   # worker service
   # The Celery worker for processing the queue.
   worker:
-    image: langgenius/dify-api:0.6.0-fix1
+    image: langgenius/dify-api:0.6.1
     restart: always
     environment:
       # Startup mode, 'worker' starts the Celery worker for processing the queue.
@@ -232,7 +232,7 @@ services:
 
   # Frontend web application.
   web:
-    image: langgenius/dify-web:0.6.0-fix1
+    image: langgenius/dify-web:0.6.1
     restart: always
     environment:
       EDITION: SELF_HOSTED

web/app/components/app-sidebar/app-info.tsx

@@ -333,7 +333,7 @@ const AppInfo = ({ expand }: IAppInfoProps) => {
               )}/>
               <div className='px-4 pb-2'>
                 <div className='flex items-center gap-1 text-gray-700 text-md leading-6 font-semibold'>
-                  {t('app.newApp.advanced')}
+                  {showSwitchTip === 'chat' ? t('app.newApp.advanced') : t('app.types.workflow')}
                   <span className='px-1 rounded-[5px] bg-white border border-black/8 text-gray-500 text-[10px] leading-[18px] font-medium'>BETA</span>
                 </div>
                 <div className='text-orange-500 text-xs leading-[18px] font-medium'>{t('app.newApp.advancedFor').toLocaleUpperCase()}</div>

web/app/components/app/create-app-modal/index.tsx

@@ -243,7 +243,7 @@ const CreateAppModal = ({ show, onSuccess, onClose }: CreateAppDialogProps) => {
                       'hidden z-20 absolute right-[26px] top-[-158px] w-[376px] rounded-xl bg-white border-[0.5px] border-[rgba(0,0,0,0.05)] shadow-lg group-hover:block',
                     )}
                   >
-                    <div className={cn('w-full h-[256px] bg-center bg-no-repeat bg-contain rounded-xl', s.basicPic)}/>
+                    <div className={cn('w-full h-[256px] bg-center bg-no-repeat bg-contain rounded-xl', s.advancedPic)}/>
                     <div className='px-4 pb-2'>
                       <div className='flex items-center justify-between'>
                         <div className='flex items-center'>

web/app/components/base/audio-btn/index.tsx

@@ -1,11 +1,12 @@
 'use client'
-import { useRef, useState } from 'react'
+import { useEffect, useRef, useState } from 'react'
 import { t } from 'i18next'
 import { useParams, usePathname } from 'next/navigation'
 import s from './style.module.css'
 import Tooltip from '@/app/components/base/tooltip'
 import { randomString } from '@/utils'
 import { textToAudio } from '@/service/share'
+import Loading from '@/app/components/base/loading'
 
 type AudioBtnProps = {
   value: string
@@ -14,6 +15,8 @@ type AudioBtnProps = {
   isAudition?: boolean
 }
 
+type AudioState = 'initial' | 'loading' | 'playing' | 'paused' | 'ended'
+
 const AudioBtn = ({
   value,
   voice,
@@ -21,9 +24,8 @@ const AudioBtn = ({
   isAudition,
 }: AudioBtnProps) => {
   const audioRef = useRef<HTMLAudioElement | null>(null)
-  const [isPlaying, setIsPlaying] = useState(false)
-  const [isPause, setPause] = useState(false)
-  const [hasEnded, setHasEnded] = useState(false)
+  const [audioState, setAudioState] = useState<AudioState>('initial')
+
   const selector = useRef(`play-tooltip-${randomString(4)}`)
   const params = useParams()
   const pathname = usePathname()
@@ -34,9 +36,11 @@ const AudioBtn = ({
     return ''
   }
 
-  const playAudio = async () => {
+  const loadAudio = async () => {
     const formData = new FormData()
     if (value !== '') {
+      setAudioState('loading')
+
       formData.append('text', removeCodeBlocks(value))
       formData.append('voice', removeCodeBlocks(voice))
 
@@ -59,67 +63,80 @@ const AudioBtn = ({
         const blob_bytes = Buffer.from(audioResponse.data, 'latin1')
         const blob = new Blob([blob_bytes], { type: 'audio/wav' })
         const audioUrl = URL.createObjectURL(blob)
-        const audio = new Audio(audioUrl)
-        audioRef.current = audio
-        audio.play().then(() => {}).catch(() => {
-          setIsPlaying(false)
-          URL.revokeObjectURL(audioUrl)
-        })
-        audio.onended = () => {
-          setHasEnded(true)
-          setIsPlaying(false)
-        }
+        audioRef.current!.src = audioUrl
       }
       catch (error) {
-        setIsPlaying(false)
+        setAudioState('initial')
         console.error('Error playing audio:', error)
       }
     }
   }
-  const togglePlayPause = () => {
+
+  const handleToggle = () => {
+    if (audioState === 'initial')
+      loadAudio()
     if (audioRef.current) {
-      if (isPlaying) {
-        if (!hasEnded) {
-          setPause(false)
-          audioRef.current.play()
-        }
-        if (!isPause) {
-          setPause(true)
-          audioRef.current.pause()
-        }
+      if (audioState === 'playing') {
+        audioRef.current.pause()
+        setAudioState('paused')
       }
-      else if (!isPlaying) {
-        if (isPause) {
-          setPause(false)
-          audioRef.current.play()
-        }
-        else {
-          setHasEnded(false)
-          playAudio().then()
-        }
+      else if (audioState === 'paused' || audioState === 'ended') {
+        audioRef.current.play()
+        setAudioState('playing')
       }
-      setIsPlaying(prevIsPlaying => !prevIsPlaying)
-    }
-    else {
-      setIsPlaying(true)
-      if (!isPlaying)
-        playAudio().then()
     }
   }
 
+  useEffect(() => {
+    const currentAudio = audioRef.current
+    const handleLoading = () => {
+      setAudioState('loading')
+    }
+    const handlePlay = () => {
+      currentAudio?.play()
+      setAudioState('playing')
+    }
+    const handleEnded = () => {
+      setAudioState('ended')
+    }
+    currentAudio?.addEventListener('progress', handleLoading)
+    currentAudio?.addEventListener('canplaythrough', handlePlay)
+    currentAudio?.addEventListener('ended', handleEnded)
+    return () => {
+      if (currentAudio) {
+        currentAudio.removeEventListener('progress', handleLoading)
+        currentAudio.removeEventListener('canplaythrough', handlePlay)
+        currentAudio.removeEventListener('ended', handleEnded)
+        URL.revokeObjectURL(currentAudio.src)
+        currentAudio.src = ''
+      }
+    }
+  }, [])
+
+  const tooltipContent = {
+    initial: t('appApi.play'),
+    ended: t('appApi.play'),
+    paused: t('appApi.pause'),
+    playing: t('appApi.playing'),
+    loading: t('appApi.loading'),
+  }[audioState]
+
   return (
-    <div className={`${(isPlaying && !hasEnded) ? 'mr-1' : className}`}>
+    <div className={`${(audioState === 'loading' || audioState === 'playing') ? 'mr-1' : className}`}>
       <Tooltip
         selector={selector.current}
-        content={(!isPause ? ((isPlaying && !hasEnded) ? t('appApi.playing') : t('appApi.play')) : t('appApi.pause')) as string}
+        content={tooltipContent}
         className='z-10'
       >
-        <div
+        <button
+          disabled={audioState === 'loading'}
           className={`box-border p-0.5 flex items-center justify-center cursor-pointer ${isAudition || '!p-0 rounded-md bg-white'}`}
-          onClick={togglePlayPause}>
-          <div className={`w-6 h-6 rounded-md ${!isAudition ? 'w-4 h-4 hover:bg-gray-50' : 'hover:bg-gray-50'} ${(isPlaying && !hasEnded) ? s.pauseIcon : s.playIcon}`}></div>
-        </div>
+          onClick={handleToggle}>
+          {audioState === 'loading' && <div className='w-6 h-6 rounded-md flex items-center justify-center p-2'><Loading /></div>}
+          {audioState !== 'loading' && <div className={`w-6 h-6 rounded-md ${!isAudition ? 'w-4 h-4 hover:bg-gray-50' : 'hover:bg-gray-50'} ${(audioState === 'playing') ? s.pauseIcon : s.playIcon}`}></div>}
+        </button>
       </Tooltip>
+      <audio ref={audioRef} src='' className='hidden' />
     </div>
   )
 }

web/app/components/base/audio-btn/style.module.css

@@ -7,4 +7,4 @@
   background-image: url(~@/app/components/develop/secret-key/assets/pause.svg);
   background-position: center;
   background-repeat: no-repeat;
-}
+}

web/app/components/base/prompt-editor/index.tsx

@@ -15,6 +15,7 @@ import { RichTextPlugin } from '@lexical/react/LexicalRichTextPlugin'
 import { ContentEditable } from '@lexical/react/LexicalContentEditable'
 import LexicalErrorBoundary from '@lexical/react/LexicalErrorBoundary'
 import { OnChangePlugin } from '@lexical/react/LexicalOnChangePlugin'
+import { HistoryPlugin } from '@lexical/react/LexicalHistoryPlugin'
 // import TreeView from './plugins/tree-view'
 import Placeholder from './plugins/placeholder'
 import ComponentPickerBlock from './plugins/component-picker-block'
@@ -208,6 +209,7 @@ const PromptEditor: FC<PromptEditorProps> = ({
         <OnChangePlugin onChange={handleEditorChange} />
         <OnBlurBlock onBlur={onBlur} onFocus={onFocus} />
         <UpdateBlock instanceId={instanceId} />
+        <HistoryPlugin />
         {/* <TreeView /> */}
       </div>
     </LexicalComposer>

web/app/components/header/account-setting/model-provider-page/declarations.ts

@@ -1,8 +1,8 @@
 export type FormValue = Record<string, any>
 
 export type TypeWithI18N<T = string> = {
-  'en-US': T
-  'zh-Hans': T
+  en_US: T
+  zh_Hans: T
   [key: string]: T
 }
 
@@ -67,16 +67,16 @@ export enum ModelStatusEnum {
 
 export const MODEL_STATUS_TEXT: { [k: string]: TypeWithI18N } = {
   'no-configure': {
-    'en-US': 'No Configure',
-    'zh-Hans': '未配置凭据',
+    en_US: 'No Configure',
+    zh_Hans: '未配置凭据',
   },
   'quota-exceeded': {
-    'en-US': 'Quota Exceeded',
-    'zh-Hans': '额度不足',
+    en_US: 'Quota Exceeded',
+    zh_Hans: '额度不足',
   },
   'no-permission': {
-    'en-US': 'No Permission',
-    'zh-Hans': '无使用权限',
+    en_US: 'No Permission',
+    zh_Hans: '无使用权限',
   },
 }
 

web/app/components/header/account-setting/model-provider-page/hooks.ts

@@ -11,11 +11,11 @@ import type {
   DefaultModel,
   DefaultModelResponse,
   Model,
-
   ModelTypeEnum,
 } from './declarations'
 import {
   ConfigurateMethodEnum,
+  ModelStatusEnum,
 } from './declarations'
 import I18n from '@/context/i18n'
 import {
@@ -132,6 +132,7 @@ export const useCurrentProviderAndModel = (modelList: Model[], defaultModel?: De
 
 export const useTextGenerationCurrentProviderAndModelAndModelList = (defaultModel?: DefaultModel) => {
   const { textGenerationModelList } = useProviderContext()
+  const activeTextGenerationModelList = textGenerationModelList.filter(model => model.status === ModelStatusEnum.active)
   const {
     currentProvider,
     currentModel,
@@ -141,6 +142,7 @@ export const useTextGenerationCurrentProviderAndModelAndModelList = (defaultMode
     currentProvider,
     currentModel,
     textGenerationModelList,
+    activeTextGenerationModelList,
   }
 }
 

web/app/components/header/account-setting/model-provider-page/model-parameter-modal/index.tsx

@@ -93,7 +93,7 @@ const ModelParameterModal: FC<ModelParameterModalProps> = ({
   const {
     currentProvider,
     currentModel,
-    textGenerationModelList,
+    activeTextGenerationModelList,
   } = useTextGenerationCurrentProviderAndModelAndModelList(
     { provider, model: modelId },
   )
@@ -114,7 +114,7 @@ const ModelParameterModal: FC<ModelParameterModalProps> = ({
   }
 
   const handleChangeModel = ({ provider, model }: DefaultModel) => {
-    const targetProvider = textGenerationModelList.find(modelItem => modelItem.provider === provider)
+    const targetProvider = activeTextGenerationModelList.find(modelItem => modelItem.provider === provider)
     const targetModelItem = targetProvider?.models.find(modelItem => modelItem.model === model)
     setModel({
       modelId: model,
@@ -223,7 +223,7 @@ const ModelParameterModal: FC<ModelParameterModalProps> = ({
                 </div>
                 <ModelSelector
                   defaultModel={(provider || modelId) ? { provider, model: modelId } : undefined}
-                  modelList={textGenerationModelList}
+                  modelList={activeTextGenerationModelList}
                   onSelect={handleChangeModel}
                 />
               </div>

web/app/components/workflow/hooks/use-nodes-interactions.ts

@@ -301,6 +301,8 @@ export const useNodesInteractions = () => {
     target,
     targetHandle,
   }) => {
+    if (source === target)
+      return
     if (getNodesReadOnly())
       return
 

web/app/components/workflow/hooks/use-workflow-run.ts

@@ -176,6 +176,8 @@ export const useWorkflowRun = () => {
           const {
             getNodes,
             setNodes,
+            edges,
+            setEdges,
           } = store.getState()
           setWorkflowRunningData(produce(workflowRunningData!, (draft) => {
             draft.task_id = task_id
@@ -192,6 +194,15 @@ export const useWorkflowRun = () => {
             })
           })
           setNodes(newNodes)
+          const newEdges = produce(edges, (draft) => {
+            draft.forEach((edge) => {
+              edge.data = {
+                ...edge.data,
+                _runned: false,
+              }
+            })
+          })
+          setEdges(newEdges)
 
           if (onWorkflowStarted)
             onWorkflowStarted(params)

web/app/components/workflow/hooks/use-workflow.ts

@@ -160,8 +160,10 @@ export const useWorkflow = () => {
 
         if (incomers.length) {
           incomers.forEach((node) => {
-            callback(node)
-            traverse(node, callback)
+            if (!list.find(n => node.id === n.id)) {
+              callback(node)
+              traverse(node, callback)
+            }
           })
         }
       }
@@ -272,7 +274,10 @@ export const useWorkflow = () => {
   }, [isVarUsedInNodes])
 
   const isValidConnection = useCallback(({ source, target }: Connection) => {
-    const { getNodes } = store.getState()
+    const {
+      edges,
+      getNodes,
+    } = store.getState()
     const nodes = getNodes()
     const sourceNode: Node = nodes.find(node => node.id === source)!
     const targetNode: Node = nodes.find(node => node.id === target)!
@@ -287,7 +292,21 @@ export const useWorkflow = () => {
         return false
     }
 
-    return true
+    const hasCycle = (node: Node, visited = new Set()) => {
+      if (visited.has(node.id))
+        return false
+
+      visited.add(node.id)
+
+      for (const outgoer of getOutgoers(node, nodes, edges)) {
+        if (outgoer.id === source)
+          return true
+        if (hasCycle(outgoer, visited))
+          return true
+      }
+    }
+
+    return !hasCycle(targetNode)
   }, [store, nodesExtraData])
 
   const formatTimeFromNow = useCallback((time: number) => {

web/app/components/workflow/nodes/_base/components/before-run-form/index.tsx

@@ -12,6 +12,7 @@ import Split from '@/app/components/workflow/nodes/_base/components/split'
 import { InputVarType, NodeRunningStatus } from '@/app/components/workflow/types'
 import ResultPanel from '@/app/components/workflow/run/result-panel'
 import Toast from '@/app/components/base/toast'
+import { TransferMethod } from '@/types/app'
 
 const i18nPrefix = 'workflow.singleRun'
 
@@ -51,7 +52,18 @@ const BeforeRunForm: FC<BeforeRunFormProps> = ({
 
   const isFinished = runningStatus === NodeRunningStatus.Succeeded || runningStatus === NodeRunningStatus.Failed
   const isRunning = runningStatus === NodeRunningStatus.Running
+  const isFileLoaded = (() => {
+    // system files
+    const filesForm = forms.find(item => !!item.values['#files#'])
+    if (!filesForm)
+      return true
 
+    const files = filesForm.values['#files#'] as any
+    if (files?.some((item: any) => item.transfer_method === TransferMethod.local_file && !item.upload_file_id))
+      return false
+
+    return true
+  })()
   const handleRun = useCallback(() => {
     let errMsg = ''
     forms.forEach((form) => {
@@ -129,7 +141,7 @@ const BeforeRunForm: FC<BeforeRunFormProps> = ({
                 <StopCircle className='w-4 h-4 text-gray-500' />
               </div>
             )}
-            <Button disabled={isRunning} type='primary' className='w-0 grow !h-8 flex items-center space-x-2 text-[13px]' onClick={handleRun}>
+            <Button disabled={!isFileLoaded || isRunning} type='primary' className='w-0 grow !h-8 flex items-center space-x-2 text-[13px]' onClick={handleRun}>
               {isRunning && <Loading02 className='animate-spin w-4 h-4 text-white' />}
               <div>{t(`${i18nPrefix}.${isRunning ? 'running' : 'startRun'}`)}</div>
             </Button>

web/app/components/workflow/nodes/knowledge-retrieval/node.tsx

@@ -1,4 +1,4 @@
-import { type FC, useEffect, useState } from 'react'
+import { type FC, useEffect, useRef, useState } from 'react'
 import React from 'react'
 import type { KnowledgeRetrievalNodeType } from './types'
 import { Folder } from '@/app/components/base/icons/src/vender/solid/files'
@@ -10,10 +10,17 @@ const Node: FC<NodeProps<KnowledgeRetrievalNodeType>> = ({
   data,
 }) => {
   const [selectedDatasets, setSelectedDatasets] = useState<DataSet[]>([])
+  const updateTime = useRef(0)
   useEffect(() => {
     (async () => {
+      updateTime.current = updateTime.current + 1
+      const currUpdateTime = updateTime.current
+
       if (data.dataset_ids?.length > 0) {
         const { data: dataSetsWithDetail } = await fetchDatasets({ url: '/datasets', params: { page: 1, ids: data.dataset_ids } })
+        //  avoid old data overwrite new data
+        if (currUpdateTime < updateTime.current)
+          return
         setSelectedDatasets(dataSetsWithDetail)
       }
       else {
@@ -33,7 +40,7 @@ const Node: FC<NodeProps<KnowledgeRetrievalNodeType>> = ({
             <div className='mr-1 shrink-0 p-1 bg-[#F5F8FF] rounded-md border-[0.5px] border-[#E0EAFF]'>
               <Folder className='w-3 h-3 text-[#444CE7]' />
             </div>
-            <div className='text-xs font-normal text-gray-700'>
+            <div className='grow w-0 text-xs font-normal text-gray-700 truncate'>
               {name}
             </div>
           </div>

web/app/components/workflow/nodes/llm/components/resolution-picker.tsx

@@ -23,7 +23,7 @@ const Item: FC<ItemProps> = ({ title, value, onSelect, isSelected }) => {
 
   return (
     <div
-      className={cn(isSelected ? 'bg-white border-[2px] border-primary-400  shadow-xs' : 'bg-gray-25 border border-gray-100', 'flex items-center h-8 px-3 rounded-xl text-[13px] font-normal text-gray-900 cursor-pointer')}
+      className={cn(isSelected ? 'bg-white border-[2px] border-primary-400  shadow-xs' : 'bg-gray-25 border border-gray-100', 'flex items-center h-8 px-3 rounded-lg text-[13px] font-normal text-gray-900 cursor-pointer')}
       onClick={handleSelect}
     >
       {title}
@@ -43,7 +43,7 @@ const ResolutionPicker: FC<Props> = ({
   const { t } = useTranslation()
 
   return (
-    <div className='flex items-center'>
+    <div className='flex items-center justify-between'>
       <div className='mr-2 text-xs font-medium text-gray-500 uppercase'>{t(`${i18nPrefix}.resolution.name`)}</div>
       <div className='flex items-center space-x-1'>
         <Item

web/app/components/workflow/nodes/llm/panel.tsx

@@ -21,6 +21,7 @@ import ResultPanel from '@/app/components/workflow/run/result-panel'
 import TooltipPlus from '@/app/components/base/tooltip-plus'
 import { HelpCircle } from '@/app/components/base/icons/src/vender/line/general'
 import Editor from '@/app/components/workflow/nodes/_base/components/prompt/editor'
+import Switch from '@/app/components/base/switch'
 const i18nPrefix = 'workflow.nodes.llm'
 
 const Panel: FC<NodePanelProps<LLMNodeType>> = ({
@@ -51,6 +52,7 @@ const Panel: FC<NodePanelProps<LLMNodeType>> = ({
     filterVar,
     handlePromptChange,
     handleMemoryChange,
+    handleVisionResolutionEnabledChange,
     handleVisionResolutionChange,
     isShowSingleRun,
     hideSingleRun,
@@ -240,12 +242,19 @@ const Panel: FC<NodePanelProps<LLMNodeType>> = ({
               title={t(`${i18nPrefix}.vision`)}
               tooltip={t('appDebug.vision.description')!}
               operations={
-                <ResolutionPicker
-                  value={inputs.vision.configs?.detail || Resolution.high}
-                  onChange={handleVisionResolutionChange}
-                />
+                <Switch size='md' defaultValue={inputs.vision.enabled} onChange={handleVisionResolutionEnabledChange} />
               }
-            />
+            >
+              {inputs.vision.enabled
+                ? (
+                  <ResolutionPicker
+                    value={inputs.vision.configs?.detail || Resolution.high}
+                    onChange={handleVisionResolutionChange}
+                  />
+                )
+                : null}
+
+            </Field>
           </>
         )}
       </div>

web/app/components/workflow/nodes/llm/use-config.ts

@@ -103,6 +103,7 @@ const useConfig = (id: string, payload: LLMNodeType) => {
   // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [defaultConfig, isChatModel])
 
+  const [modelChanged, setModelChanged] = useState(false)
   const {
     currentProvider,
     currentModel,
@@ -118,6 +119,7 @@ const useConfig = (id: string, payload: LLMNodeType) => {
         appendDefaultPromptConfig(draft, defaultConfig, model.mode === 'chat')
     })
     setInputs(newInputs)
+    setModelChanged(true)
   }, [setInputs, defaultConfig, appendDefaultPromptConfig])
 
   useEffect(() => {
@@ -146,7 +148,35 @@ const useConfig = (id: string, payload: LLMNodeType) => {
     },
   )
   const isShowVisionConfig = !!currModel?.features?.includes(ModelFeatureEnum.vision)
-
+  // change to vision model to set vision enabled, else disabled
+  useEffect(() => {
+    if (!modelChanged)
+      return
+    setModelChanged(false)
+    if (!isShowVisionConfig) {
+      const newInputs = produce(inputs, (draft) => {
+        draft.vision = {
+          enabled: false,
+        }
+      })
+      setInputs(newInputs)
+      return
+    }
+    if (!inputs.vision?.enabled) {
+      const newInputs = produce(inputs, (draft) => {
+        if (!draft.vision?.enabled) {
+          draft.vision = {
+            enabled: true,
+            configs: {
+              detail: Resolution.high,
+            },
+          }
+        }
+      })
+      setInputs(newInputs)
+    }
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isShowVisionConfig, modelChanged])
   // variables
   const { handleVarListChange, handleAddVariable } = useVarList<LLMNodeType>({
     inputs,
@@ -176,6 +206,28 @@ const useConfig = (id: string, payload: LLMNodeType) => {
     setInputs(newInputs)
   }, [inputs, setInputs])
 
+  const handleVisionResolutionEnabledChange = useCallback((enabled: boolean) => {
+    const newInputs = produce(inputs, (draft) => {
+      if (!draft.vision) {
+        draft.vision = {
+          enabled,
+          configs: {
+            detail: Resolution.high,
+          },
+        }
+      }
+      else {
+        draft.vision.enabled = enabled
+        if (!draft.vision.configs) {
+          draft.vision.configs = {
+            detail: Resolution.high,
+          }
+        }
+      }
+    })
+    setInputs(newInputs)
+  }, [inputs, setInputs])
+
   const handleVisionResolutionChange = useCallback((newResolution: Resolution) => {
     const newInputs = produce(inputs, (draft) => {
       if (!draft.vision.configs) {
@@ -296,6 +348,7 @@ const useConfig = (id: string, payload: LLMNodeType) => {
     filterVar,
     handlePromptChange,
     handleMemoryChange,
+    handleVisionResolutionEnabledChange,
     handleVisionResolutionChange,
     isShowSingleRun,
     hideSingleRun,

web/app/components/workflow/panel/inputs-panel.tsx

@@ -16,6 +16,7 @@ import {
 } from '../store'
 import { useWorkflowRun } from '../hooks'
 import type { StartNodeType } from '../nodes/start/types'
+import { TransferMethod } from '../../base/text-generation/types'
 import Button from '@/app/components/base/button'
 import { useFeatures } from '@/app/components/base/features/hooks'
 
@@ -75,6 +76,13 @@ const InputsPanel = ({ onRun }: Props) => {
     handleRun({ inputs, files })
   }
 
+  const canRun = (() => {
+    if (files?.some(item => (item.transfer_method as any) === TransferMethod.local_file && !item.upload_file_id))
+      return false
+
+    return true
+  })()
+
   return (
     <>
       <div className='px-4 pb-2'>
@@ -97,7 +105,7 @@ const InputsPanel = ({ onRun }: Props) => {
       <div className='flex items-center justify-between px-4 py-2'>
         <Button
           type='primary'
-          disabled={workflowRunningData?.result?.status === WorkflowRunningStatus.Running}
+          disabled={!canRun || workflowRunningData?.result?.status === WorkflowRunningStatus.Running}
           className='py-0 w-full h-8 rounded-lg text-[13px] font-medium'
           onClick={doRun}
         >

web/app/components/workflow/utils.ts

@@ -24,6 +24,60 @@ import type { ToolNodeType } from './nodes/tool/types'
 import { CollectionType } from '@/app/components/tools/types'
 import { toolParametersToFormSchemas } from '@/app/components/tools/utils/to-form-schema'
 
+const WHITE = 'WHITE'
+const GRAY = 'GRAY'
+const BLACK = 'BLACK'
+
+const isCyclicUtil = (nodeId: string, color: Record<string, string>, adjaList: Record<string, string[]>, stack: string[]) => {
+  color[nodeId] = GRAY
+  stack.push(nodeId)
+
+  for (let i = 0; i < adjaList[nodeId].length; ++i) {
+    const childId = adjaList[nodeId][i]
+
+    if (color[childId] === GRAY) {
+      stack.push(childId)
+      return true
+    }
+    if (color[childId] === WHITE && isCyclicUtil(childId, color, adjaList, stack))
+      return true
+  }
+  color[nodeId] = BLACK
+  if (stack.length > 0 && stack[stack.length - 1] === nodeId)
+    stack.pop()
+  return false
+}
+
+const getCycleEdges = (nodes: Node[], edges: Edge[]) => {
+  const adjaList: Record<string, string[]> = {}
+  const color: Record<string, string> = {}
+  const stack: string[] = []
+
+  for (const node of nodes) {
+    color[node.id] = WHITE
+    adjaList[node.id] = []
+  }
+
+  for (const edge of edges)
+    adjaList[edge.source].push(edge.target)
+
+  for (let i = 0; i < nodes.length; i++) {
+    if (color[nodes[i].id] === WHITE)
+      isCyclicUtil(nodes[i].id, color, adjaList, stack)
+  }
+
+  const cycleEdges = []
+  if (stack.length > 0) {
+    const cycleNodes = new Set(stack)
+    for (const edge of edges) {
+      if (cycleNodes.has(edge.source) && cycleNodes.has(edge.target))
+        cycleEdges.push(edge)
+    }
+  }
+
+  return cycleEdges
+}
+
 export const initialNodes = (nodes: Node[], edges: Edge[]) => {
   const firstNode = nodes[0]
 
@@ -35,6 +89,7 @@ export const initialNodes = (nodes: Node[], edges: Edge[]) => {
       }
     })
   }
+
   return nodes.map((node) => {
     node.type = 'custom'
 
@@ -75,7 +130,11 @@ export const initialEdges = (edges: Edge[], nodes: Node[]) => {
 
     return acc
   }, {} as Record<string, Node>)
-  return edges.map((edge) => {
+
+  const cycleEdges = getCycleEdges(nodes, edges)
+  return edges.filter((edge) => {
+    return !cycleEdges.find(cycEdge => cycEdge.source === edge.source && cycEdge.target === edge.target)
+  }).map((edge) => {
     edge.type = 'custom'
 
     if (!edge.sourceHandle)

web/i18n/en-US/app-api.ts

@@ -9,6 +9,7 @@ const translation = {
   play: 'Play',
   pause: 'Pause',
   playing: 'Playing',
+  loading: 'Loading',
   merMaind: {
     rerender: 'Redo Rerender',
   },

web/i18n/zh-Hans/app-api.ts

@@ -9,6 +9,7 @@ const translation = {
   play: '播放',
   pause: '暂停',
   playing: '播放中',
+  loading: '加载中',
   merMaind: {
     rerender: '重新渲染',
   },

web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dify-web",
-  "version": "0.6.0-fix1",
+  "version": "0.6.1",
   "private": true,
   "scripts": {
     "dev": "next dev",

web/utils/model-config.ts

@@ -15,6 +15,9 @@ export const userInputsFormToPromptVariables = (useInputs: UserInputFormItem[] |
       if (item['text-input'])
         return ['string', item['text-input']]
 
+      if (item.number)
+        return ['number', item.number]
+
       if (item.external_data_tool)
         return [item.external_data_tool.type, item.external_data_tool]