Add application file

.gitignore

@@ -0,0 +1,162 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

.pre-commit-config.yaml

@@ -0,0 +1,46 @@
+exclude: ^(tests/data|scripts|frontend/React)/
+repos:
+  - repo: https://github.com/PyCQA/flake8
+    rev: 7.0.0
+    hooks:
+      - id: flake8
+        args: ["--max-line-length=120"]
+  - repo: https://github.com/PyCQA/isort
+    rev: 5.13.2
+    hooks:
+      - id: isort
+  - repo: https://github.com/pre-commit/mirrors-yapf
+    rev: v0.32.0
+    hooks:
+      - id: yapf
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.5.0
+    hooks:
+      - id: trailing-whitespace
+      - id: check-yaml
+      - id: end-of-file-fixer
+      - id: requirements-txt-fixer
+      - id: double-quote-string-fixer
+      - id: check-merge-conflict
+      - id: fix-encoding-pragma
+        args: ["--remove"]
+      - id: mixed-line-ending
+        args: ["--fix=lf"]
+  - repo: https://github.com/executablebooks/mdformat
+    rev: 0.7.17
+    hooks:
+      - id: mdformat
+        args: ["--number"]
+        additional_dependencies:
+          - mdformat-openmmlab
+          - mdformat_frontmatter
+          - linkify-it-py
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.2.6
+    hooks:
+      - id: codespell
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v3.15.0
+    hooks:
+      - id: pyupgrade
+        args: ["--py36-plus"]

.pylintrc

@@ -0,0 +1,428 @@
+# This Pylint rcfile contains a best-effort configuration to uphold the
+# best-practices and style described in the Google Python style guide:
+#   https://google.github.io/styleguide/pyguide.html
+#
+# Its canonical open-source location is:
+#   https://google.github.io/styleguide/pylintrc
+
+[MASTER]
+
+# Files or directories to be skipped. They should be base names, not paths.
+ignore=third_party,storage
+
+# Files or directories matching the regex patterns are skipped. The regex
+# matches against base names, not paths.
+ignore-patterns=
+
+# Pickle collected data for later comparisons.
+persistent=no
+
+# List of plugins (as comma separated values of python modules names) to load,
+# usually to register additional checkers.
+load-plugins=
+
+# Use multiple processes to speed up Pylint.
+jobs=4
+
+# Allow loading of arbitrary C extensions. Extensions are imported into the
+# active Python interpreter and may run arbitrary code.
+unsafe-load-any-extension=no
+
+
+[MESSAGES CONTROL]
+
+# Only show warnings with the listed confidence levels. Leave empty to show
+# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED
+confidence=
+
+# Enable the message, report, category or checker with the given id(s). You can
+# either give multiple identifier separated by comma (,) or put this option
+# multiple time (only on the command line, not in the configuration file where
+# it should appear only once). See also the "--disable" option for examples.
+#enable=
+
+# Disable the message, report, category or checker with the given id(s). You
+# can either give multiple identifiers separated by comma (,) or put this
+# option multiple times (only on the command line, not in the configuration
+# file where it should appear only once).You can also use "--disable=all" to
+# disable everything first and then reenable specific checks. For example, if
+# you want to run only the similarities checker, you can use "--disable=all
+# --enable=similarities". If you want to run only the classes checker, but have
+# no Warning level messages displayed, use"--disable=all --enable=classes
+# --disable=W"
+disable=abstract-method,
+        apply-builtin,
+        arguments-differ,
+        attribute-defined-outside-init,
+        backtick,
+        bad-option-value,
+        basestring-builtin,
+        buffer-builtin,
+        c-extension-no-member,
+        consider-using-enumerate,
+        cmp-builtin,
+        cmp-method,
+        coerce-builtin,
+        coerce-method,
+        delslice-method,
+        div-method,
+        duplicate-code,
+        eq-without-hash,
+        execfile-builtin,
+        file-builtin,
+        filter-builtin-not-iterating,
+        fixme,
+        getslice-method,
+        global-statement,
+        hex-method,
+        idiv-method,
+        implicit-str-concat,
+        import-error,
+        import-self,
+        import-star-module-level,
+        inconsistent-return-statements,
+        input-builtin,
+        intern-builtin,
+        invalid-str-codec,
+        locally-disabled,
+        long-builtin,
+        long-suffix,
+        map-builtin-not-iterating,
+        misplaced-comparison-constant,
+        missing-function-docstring,
+        metaclass-assignment,
+        next-method-called,
+        next-method-defined,
+        no-absolute-import,
+        no-else-break,
+        no-else-continue,
+        no-else-raise,
+        no-else-return,
+        no-init,  # added
+        no-member,
+        no-name-in-module,
+        no-self-use,
+        nonzero-method,
+        oct-method,
+        old-division,
+        old-ne-operator,
+        old-octal-literal,
+        old-raise-syntax,
+        parameter-unpacking,
+        print-statement,
+        raising-string,
+        range-builtin-not-iterating,
+        raw_input-builtin,
+        rdiv-method,
+        reduce-builtin,
+        relative-import,
+        reload-builtin,
+        round-builtin,
+        setslice-method,
+        signature-differs,
+        standarderror-builtin,
+        suppressed-message,
+        sys-max-int,
+        too-few-public-methods,
+        too-many-ancestors,
+        too-many-arguments,
+        too-many-boolean-expressions,
+        too-many-branches,
+        too-many-instance-attributes,
+        too-many-locals,
+        too-many-nested-blocks,
+        too-many-public-methods,
+        too-many-return-statements,
+        too-many-statements,
+        trailing-newlines,
+        unichr-builtin,
+        unicode-builtin,
+        unnecessary-pass,
+        unpacking-in-except,
+        useless-else-on-loop,
+        useless-object-inheritance,
+        useless-suppression,
+        using-cmp-argument,
+        wrong-import-order,
+        xrange-builtin,
+        zip-builtin-not-iterating,
+
+
+[REPORTS]
+
+# Set the output format. Available formats are text, parseable, colorized, msvs
+# (visual studio) and html. You can also give a reporter class, eg
+# mypackage.mymodule.MyReporterClass.
+output-format=colorized
+
+# Tells whether to display a full report or only the messages
+reports=no
+
+# Python expression which should return a note less than 10 (10 is the highest
+# note). You have access to the variables errors warning, statement which
+# respectively contain the number of errors / warnings messages and the total
+# number of statements analyzed. This is used by the global evaluation report
+# (RP0004).
+evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
+
+# Template used to display messages. This is a python new-style format string
+# used to format the message information. See doc for all details
+#msg-template=
+
+
+[BASIC]
+
+# Good variable names which should always be accepted, separated by a comma
+good-names=main,_
+
+# Bad variable names which should always be refused, separated by a comma
+bad-names=
+
+# Colon-delimited sets of names that determine each other's naming style when
+# the name regexes allow several styles.
+name-group=
+
+# Include a hint for the correct naming format with invalid-name
+include-naming-hint=no
+
+# List of decorators that produce properties, such as abc.abstractproperty. Add
+# to this list to register other decorators that produce valid properties.
+property-classes=abc.abstractproperty,cached_property.cached_property,cached_property.threaded_cached_property,cached_property.cached_property_with_ttl,cached_property.threaded_cached_property_with_ttl
+
+# Regular expression matching correct function names
+function-rgx=^(?:(?P<exempt>setUp|tearDown|setUpModule|tearDownModule)|(?P<camel_case>_?[A-Z][a-zA-Z0-9]*)|(?P<snake_case>_?[a-z][a-z0-9_]*))$
+
+# Regular expression matching correct variable names
+variable-rgx=^[a-z][a-z0-9_]*$
+
+# Regular expression matching correct constant names
+const-rgx=^(_?[A-Z][A-Z0-9_]*|__[a-z0-9_]+__|_?[a-z][a-z0-9_]*)$
+
+# Regular expression matching correct attribute names
+attr-rgx=^_{0,2}[a-z][a-z0-9_]*$
+
+# Regular expression matching correct argument names
+argument-rgx=^[a-z][a-z0-9_]*$
+
+# Regular expression matching correct class attribute names
+class-attribute-rgx=^(_?[A-Z][A-Z0-9_]*|__[a-z0-9_]+__|_?[a-z][a-z0-9_]*)$
+
+# Regular expression matching correct inline iteration names
+inlinevar-rgx=^[a-z][a-z0-9_]*$
+
+# Regular expression matching correct class names
+class-rgx=^_?[A-Z][a-zA-Z0-9]*$
+
+# Regular expression matching correct module names
+module-rgx=^(_?[a-z][a-z0-9_]*|__init__)$
+
+# Regular expression matching correct method names
+method-rgx=(?x)^(?:(?P<exempt>_[a-z0-9_]+__|runTest|setUp|tearDown|setUpTestCase|tearDownTestCase|setupSelf|tearDownClass|setUpClass|(test|assert)_*[A-Z0-9][a-zA-Z0-9_]*|next)|(?P<camel_case>_{0,2}[A-Z][a-zA-Z0-9_]*)|(?P<snake_case>_{0,2}[a-z][a-z0-9_]*))$
+
+# Regular expression which should only match function or class names that do
+# not require a docstring.
+no-docstring-rgx=(__.*__|main|test.*|.*test|.*Test)$
+
+# Minimum line length for functions/classes that require docstrings, shorter
+# ones are exempt.
+docstring-min-length=10
+
+
+[TYPECHECK]
+
+# List of decorators that produce context managers, such as
+# contextlib.contextmanager. Add to this list to register other decorators that
+# produce valid context managers.
+contextmanager-decorators=contextlib.contextmanager,contextlib2.contextmanager
+
+# Tells whether missing members accessed in mixin class should be ignored. A
+# mixin class is detected if its name ends with "mixin" (case insensitive).
+ignore-mixin-members=yes
+
+# List of module names for which member attributes should not be checked
+# (useful for modules/projects where namespaces are manipulated during runtime
+# and thus existing member attributes cannot be deduced by static analysis. It
+# supports qualified module names, as well as Unix pattern matching.
+ignored-modules=
+
+# List of class names for which member attributes should not be checked (useful
+# for classes with dynamically set attributes). This supports the use of
+# qualified names.
+ignored-classes=optparse.Values,thread._local,_thread._local
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E1101 when accessed. Python regular
+# expressions are accepted.
+generated-members=
+
+
+[FORMAT]
+
+# Maximum number of characters on a single line.
+max-line-length=120
+
+# TODO(https://github.com/PyCQA/pylint/issues/3352): Direct pylint to exempt
+# lines made too long by directives to pytype.
+
+# Regexp for a line that is allowed to be longer than the limit.
+ignore-long-lines=(?x)(
+  ^\s*(\#\ )?<?https?://\S+>?$|
+  ^\s*(from\s+\S+\s+)?import\s+.+$)
+
+# Allow the body of an if to be on the same line as the test if there is no
+# else.
+single-line-if-stmt=yes
+
+# Maximum number of lines in a module
+max-module-lines=99999
+
+# String used as indentation unit.  The internal Google style guide mandates 2
+# spaces.  Google's externaly-published style guide says 4, consistent with
+# PEP 8.  Here, we use 2 spaces, for conformity with many open-sourced Google
+# projects (like TensorFlow).
+indent-string='    '
+
+# Number of spaces of indent required inside a hanging  or continued line.
+indent-after-paren=4
+
+# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
+expected-line-ending-format=
+
+
+[MISCELLANEOUS]
+
+# List of note tags to take in consideration, separated by a comma.
+notes=TODO
+
+
+[STRING]
+
+# This flag controls whether inconsistent-quotes generates a warning when the
+# character used as a quote delimiter is used inconsistently within a module.
+check-quote-consistency=yes
+
+
+[VARIABLES]
+
+# Tells whether we should check for unused import in __init__ files.
+init-import=no
+
+# A regular expression matching the name of dummy variables (i.e. expectedly
+# not used).
+dummy-variables-rgx=^\*{0,2}(_$|unused_|dummy_)
+
+# List of additional names supposed to be defined in builtins. Remember that
+# you should avoid to define new builtins when possible.
+additional-builtins=
+
+# List of strings which can identify a callback function by name. A callback
+# name must start or end with one of those strings.
+callbacks=cb_,_cb
+
+# List of qualified module names which can have objects that can redefine
+# builtins.
+redefining-builtins-modules=six,six.moves,past.builtins,future.builtins,functools
+
+
+[LOGGING]
+
+# Logging modules to check that the string format arguments are in logging
+# function parameter format
+logging-modules=logging,absl.logging,tensorflow.io.logging
+
+
+[SIMILARITIES]
+
+# Minimum lines number of a similarity.
+min-similarity-lines=4
+
+# Ignore comments when computing similarities.
+ignore-comments=yes
+
+# Ignore docstrings when computing similarities.
+ignore-docstrings=yes
+
+# Ignore imports when computing similarities.
+ignore-imports=no
+
+
+[SPELLING]
+
+# Spelling dictionary name. Available dictionaries: none. To make it working
+# install python-enchant package.
+spelling-dict=
+
+# List of comma separated words that should not be checked.
+spelling-ignore-words=
+
+# A path to a file that contains private dictionary; one word per line.
+spelling-private-dict-file=
+
+# Tells whether to store unknown words to indicated private dictionary in
+# --spelling-private-dict-file option instead of raising a message.
+spelling-store-unknown-words=no
+
+
+[IMPORTS]
+
+# Deprecated modules which should not be used, separated by a comma
+deprecated-modules=regsub,
+                   TERMIOS,
+                   Bastion,
+                   rexec,
+                   sets
+
+# Create a graph of every (i.e. internal and external) dependencies in the
+# given file (report RP0402 must not be disabled)
+import-graph=
+
+# Create a graph of external dependencies in the given file (report RP0402 must
+# not be disabled)
+ext-import-graph=
+
+# Create a graph of internal dependencies in the given file (report RP0402 must
+# not be disabled)
+int-import-graph=
+
+# Force import order to recognize a module as part of the standard
+# compatibility libraries.
+known-standard-library=
+
+# Force import order to recognize a module as part of a third party library.
+known-third-party=enchant, absl
+
+# Analyse import fallback blocks. This can be used to support both Python 2 and
+# 3 compatible code, which means that the block might have code that exists
+# only in one or another interpreter, leading to false positives when analysed.
+analyse-fallback-blocks=no
+
+
+[CLASSES]
+
+# List of method names used to declare (i.e. assign) instance attributes.
+defining-attr-methods=__init__,
+                      __new__,
+                      setUp
+
+# List of member names, which should be excluded from the protected access
+# warning.
+exclude-protected=_asdict,
+                  _fields,
+                  _replace,
+                  _source,
+                  _make
+
+# List of valid names for the first argument in a class method.
+valid-classmethod-first-arg=cls,
+                            class_
+
+# List of valid names for the first argument in a metaclass class method.
+valid-metaclass-classmethod-first-arg=mcs
+
+
+[EXCEPTIONS]
+
+# Exceptions that will emit a warning when being caught. Defaults to
+# "Exception"
+overgeneral-exceptions=builtins.BaseException,
+                       builtins.Exception

Dockerfile

@@ -0,0 +1,26 @@
+FROM continuumio/miniconda3
+
+ARG OPENAI_API_KEY
+ENV OPENAI_API_KEY=${OPENAI_API_KEY}
+
+ARG BING_API_KEY
+ENV BING_API_KEY=${BING_API_KEY}
+
+# 设置环境变量
+ENV PATH=/opt/conda/bin:$PATH
+
+# 克隆git仓库
+RUN git clone https://github.com/InternLM/MindSearch.git /app
+
+WORKDIR /app
+
+# 创建并激活 fastapi 环境，并安装依赖包
+RUN conda create --name fastapi python=3.10 -y && \
+    conda run -n fastapi pip install -r requirements.txt && \
+    conda clean --all -f -y
+
+# 暴露 FastAPI 默认端口
+EXPOSE 8000
+
+# 启动 FastAPI 服务
+CMD ["conda", "run", "--no-capture-output", "-n", "fastapi", "uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,12 +1,122 @@
----
-title: Mindsearch
-emoji: 👁
-colorFrom: yellow
-colorTo: gray
-sdk: streamlit
-sdk_version: 1.37.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<div id="top"></div>
+
+<div align="center">
+
+<img src="assets/logo.svg" style="width: 50%; height: auto;">
+
+[🌐 Project Page](https://mindsearch.netlify.app/) | [📃 Paper](https://arxiv.org/abs/2407.20183) | [💻 Playground](https://mindsearch.openxlab.org.cn/)
+
+English | [简体中文](README_zh-CN.md)
+
+<https://github.com/user-attachments/assets/44ffe4b9-be26-4b93-a77b-02fed16e33fe>
+
+</div>
+</p>
+
+## ✨ MindSearch: Mimicking Human Minds Elicits Deep AI Searcher
+
+MindSearch is an open-source AI Search Engine Framework with Perplexity.ai Pro performance. You can simply deploy it with your own perplexity.ai style search engine with either close-source LLMs (GPT, Claude) or open-source LLMs (InternLM2.5-7b-chat). It owns following features:
+
+- 🤔 **Ask everything you want to know**: MindSearch is designed to solve any question in your life and use web knowledge.
+- 📚 **In-depth Knowledge Discovery**: MindSearch browses hundreds of web pages to answer your question, providing deeper and wider knowledge base answer.
+- 🔍 **Detailed Solution Path**: MindSearch exposes all details, allowing users to check everything they want. This greatly improves the credibility of its final response as well as usability.
+- 💻 **Optimized UI Experimence**: Providing all kinds of interfaces for users, including React, Gradio, Streamlit and Terminal. Choose any type based on your need.
+- 🧠 **Dynamic Graph Construction Process**: MindSearch decomposes the user query into atomic sub-questions as nodes in the graph and progressively extends the graph based on the search result from WebSearcher.
+
+<div align="center">
+
+<img src="assets/teaser.gif">
+
+</div>
+
+## ⚡️ MindSearch vs other AI Search Engines
+
+Comparison on human preference based on depth, breadth, factuality of the response generated by ChatGPT-Web, Perplexity.ai (Pro), and MindSearch. Results are obtained on 100 human-crafted real-world questions and evaluated by 5 human experts\*.
+
+<div align="center">
+<img src="assets/mindsearch_openset.png" width="90%">
+</div>
+* All experiments are done before July.7 2024.
+
+## ⚽️ Build Your Own MindSearch
+
+### Step1: Dependencies Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+### Step2: Setup MindSearch API
+
+Setup FastAPI Server.
+
+```bash
+python -m mindsearch.app --lang en --model_format internlm_server
+```
+
+- `--lang`: language of the model, `en` for English and `zh` for Chinese.
+- `--model_format`: format of the model.
+  - `internlm_server` for InternLM2.5-7b-chat with local server. (InternLM2.5-7b-chat has been better optimized for Chinese.)
+  - `gpt4` for GPT4.
+    if you want to use other models, please modify [models](./mindsearch/agent/models.py)
+
+### Step3: Setup MindSearch Frontend
+
+Providing following frontend interfaces,
+
+- React
+
+```bash
+# Install Node.js and npm
+# for Ubuntu
+sudo apt install nodejs npm
+
+# for windows
+# download from https://nodejs.org/zh-cn/download/prebuilt-installer
+
+# Install dependencies
+
+cd frontend/React
+npm install
+npm start
+```
+
+Details can be found in [React](./frontend/React/README.md)
+
+- Gradio
+
+```bash
+python frontend/mindsearch_gradio.py
+```
+
+- Streamlit
+
+```bash
+streamlit run frontend/mindsearch_streamlit.py
+```
+
+## 🐞 Debug Locally
+
+```bash
+python -m mindsearch.terminal
+```
+
+## 📝 License
+
+This project is released under the [Apache 2.0 license](LICENSE).
+
+## Citation
+
+If you find this project useful in your research, please consider cite:
+
+```
+@misc{chen2024mindsearchmimickinghumanminds,
+      title={MindSearch: Mimicking Human Minds Elicits Deep AI Searcher},
+      author={Zehui Chen and Kuikun Liu and Qiuchen Wang and Jiangning Liu and Wenwei Zhang and Kai Chen and Feng Zhao},
+      year={2024},
+      eprint={2407.20183},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2407.20183},
+}
+```

README_zh-CN.md

@@ -0,0 +1,119 @@
+<div id="top"></div>
+
+<div align="center">
+
+<img src="assets/logo.svg" style="width: 50%; height: auto;">
+
+[🌐 Project Page](https://mindsearch.netlify.app/) | [📃 Paper](https://arxiv.org/abs/2407.20183) | [💻 Playground](https://mindsearch.openxlab.org.cn/)
+
+[English](README.md) | 简体中文
+
+<https://github.com/user-attachments/assets/b4312e9c-5b40-43e5-8c69-929c373e4965>
+
+</div>
+</p>
+
+## ✨ MindSearch: Mimicking Human Minds Elicits Deep AI Searcher
+
+MindSearch 是一个开源的 AI 搜索引擎框架，具有与 Perplexity.ai Pro 相同的性能。您可以轻松部署它来构建您自己的搜索引擎，可以使用闭源 LLM（如 GPT、Claude）或开源 LLM（如 InternLM2.5-7b-chat）。其拥有以下特性：
+
+- 🤔 **任何想知道的问题**：MindSearch 通过搜索解决你在生活中遇到的各种问题
+- 📚 **深度知识探索**：MindSearch 通过数百网页的浏览，提供更广泛、深层次的答案
+- 🔍 **透明的解决方案路径**：MindSearch 提供了思考路径、搜索关键词等完整的内容，提高回复的可信度和可用性。
+- 💻 **多种用户界面**：为用户提供各种接口，包括 React、Gradio、Streamlit 和本地调试。根据需要选择任意类型。
+- 🧠 **动态图构建过程**：MindSearch 将用户查询分解为图中的子问题节点，并根据 WebSearcher 的搜索结果逐步扩展图。
+
+<div align="center">
+
+<img src="assets/teaser.gif">
+
+</div>
+
+## ⚡️ MindSearch VS 其他 AI 搜索引擎
+
+在深度、广度和生成响应的准确性三个方面，对 ChatGPT-Web、Perplexity.ai（Pro）和 MindSearch 的表现进行比较。评估结果基于 100 个由人类专家精心设计的现实问题，并由 5 位专家进行评分\*。
+
+<div align="center">
+<img src="assets/mindsearch_openset.png" width="90%">
+</div>
+* 所有实验均在 2024 年 7 月 7 日之前完成。
+
+## ⚽️ 构建您自己的 MindSearch
+
+### 步骤1: 依赖安装
+
+```bash
+pip install -r requirements.txt
+```
+
+### 步骤2: 启动 MindSearch API
+
+启动 FastAPI 服务器
+
+```bash
+python -m mindsearch.app --lang en --model_format internlm_server
+```
+
+- `--lang`: 模型的语言，`en` 为英语，`zh` 为中文。
+- `--model_format`: 模型的格式。
+  - `internlm_server` 为 InternLM2.5-7b-chat 本地服务器。
+  - `gpt4` 为 GPT4。
+    如果您想使用其他模型，请修改 [models](./mindsearch/agent/models.py)
+
+### 步骤3: 启动 MindSearch 前端
+
+提供以下几种前端界面：
+
+- React
+
+```bash
+# 安装 Node.js 和 npm
+# 对于 Ubuntu
+sudo apt install nodejs npm
+# 对于 Windows
+# 从 https://nodejs.org/zh-cn/download/prebuilt-installer 下载
+
+cd frontend/React
+npm install
+npm start
+```
+
+更多细节请参考 [React](./frontend/React/README.md)
+
+- Gradio
+
+```bash
+python frontend/mindsearch_gradio.py
+```
+
+- Streamlit
+
+```bash
+streamlit run frontend/mindsearch_streamlit.py
+```
+
+## 🐞 本地调试
+
+```bash
+python mindsearch/terminal.py
+```
+
+## 📝 许可证
+
+该项目按照 [Apache 2.0 许可证](LICENSE) 发行。
+
+## 学术引用
+
+如果此项目对您的研究有帮助，请参考如下方式进行引用：
+
+```
+@misc{chen2024mindsearchmimickinghumanminds,
+      title={MindSearch: Mimicking Human Minds Elicits Deep AI Searcher},
+      author={Zehui Chen and Kuikun Liu and Qiuchen Wang and Jiangning Liu and Wenwei Zhang and Kai Chen and Feng Zhao},
+      year={2024},
+      eprint={2407.20183},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2407.20183},
+}
+```

frontend/React/.gitignore

@@ -0,0 +1,20 @@
+
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+
+# testing
+/coverage
+
+# production
+/build
+
+# misc
+.DS_Store
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*

frontend/React/.prettierignore

@@ -0,0 +1,7 @@
+dist
+deploy
+values
+node_modules
+.gitignore
+.prettierignore
+.husky

frontend/React/.prettierrc.json

@@ -0,0 +1,7 @@
+{
+    "printWidth": 120,
+    "tabWidth": 4,
+    "singleQuote": true,
+    "quoteProps": "as-needed",
+    "bracketSpacing": true
+}

frontend/React/README.md

@@ -0,0 +1,132 @@
+# 开始
+## 准备node.js开发环境
+Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境，允许你在服务器端运行 JavaScript。以下是在 Windows、Linux 和 macOS 上安装 Node.js 的详细步骤。
+
+### 在 Windows 上安装 Node.js
+- 步骤 1: 访问 Node.js 官网
+
+打开浏览器，访问 [Node.js](https://nodejs.org/zh-cn/download/prebuilt-installer) 官方网站。
+
+- 步骤 2: 下载 Node.js 安装包
+
+选择你需要的nodejs版本，设备的类型，点击下载，示例如下图：
+![windows install](./windows-.png)
+
+- 步骤 3: 安装 Node.js
+
+双击下载的安装包开始安装。
+
+跟随安装向导的指示进行安装。在安装过程中，你可以选择安装位置、是否将 Node.js 添加到系统 PATH 环境变量等选项。推荐选择“添加到 PATH”以便在任何地方都能通过命令行访问 Node.js。
+安装完成后，点击“Finish”结束安装。
+
+- 步骤 4: 验证安装
+
+打开命令提示符（CMD）或 PowerShell。
+输入 node -v 并回车，如果系统返回了 Node.js 的版本号，说明安装成功。
+接着，输入 npm -v 并回车，npm 是 Node.js 的包管理器，如果返回了版本号，表示 npm 也已正确安装。
+
+### 在 Linux 上安装 Node.js
+注意： 由于 Linux 发行版众多，以下以 Ubuntu 为例说明，其他发行版（如 CentOS、Debian 等）的安装方式可能略有不同，可自行查询对应的安装办法。
+
+- 步骤 1: 更新你的包管理器
+
+打开终端。
+
+输入 sudo apt update 并回车，以更新 Ubuntu 的包索引。
+
+- 步骤 2: 安装 Node.js
+
+对于 Ubuntu 18.04 及更高版本，Node.js 可以直接从 Ubuntu 的仓库中安装。
+输入 sudo apt install nodejs npm 并回车。
+对于旧版本的 Ubuntu 或需要安装特定版本的 Node.js，你可能需要使用如 NodeSource 这样的第三方仓库。
+
+- 步骤 3: 验证安装
+
+在终端中，输入 node -v 和 npm -v 来验证 Node.js 和 npm 是否已正确安装。
+
+### 在 macOS 上安装 Node.js
+
+#### 下载安装
+- 步骤 1: 访问 Node.js 官网
+
+打开浏览器，访问 Node.js 官方网站。
+
+- 步骤 2: 下载 Node.js 安装包
+
+在首页找到 macOS 对应的安装包（通常是 .pkg 文件），点击下载。
+
+- 步骤 3: 安装 Node.js
+
+找到下载的 .pkg 文件，双击打开。
+跟随安装向导的指示进行安装。
+安装完成后，点击“Close”结束安装。
+
+- 步骤 4: 验证安装
+
+打开终端。
+
+输入 node -v 和 npm -v 来验证 Node.js 和 npm 是否已正确安装。
+
+#### 使用HomeBrew安装
+前提条件：确保你的macOS上已经安装了Homebrew。如果尚未安装，可以通过以下命令进行安装（以终端操作为例）：
+```
+  /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+```
+按照提示输入密码以确认安装。安装过程中，可能需要你同意许可协议等。
+
+- 打开终端：
+在macOS上找到并打开“终端”应用程序。
+
+- 使用Homebrew安装Node.js：
+在终端中输入以下命令来安装最新版本的Node.js
+```
+  brew install node
+```
+Homebrew会自动下载Node.js的安装包，并处理相关的依赖项和安装过程。你需要等待一段时间，直到安装完成。
+
+- 验证安装：
+安装完成后，你可以通过输入以下命令来验证Node.js是否成功安装：
+```
+  node -v
+```
+如果终端输出了Node.js的版本号，那么表示安装成功。同时，你也可以通过输入npm -v来验证npm（Node.js的包管理器）是否也成功安装。
+
+完成以上步骤后，你应该能在你的 Windows、Linux 或 macOS 系统上成功安装并运行 Node.js。
+
+### 更多
+如需了解更多，可参照：https://nodejs.org/en
+
+如环境已经准备好，跳转下一步
+
+## 安装依赖
+进入前端项目根目录
+```
+  npm install
+```
+
+## 启动
+```
+  npm start
+```
+
+启动成功后，界面将出现可访问的本地url
+
+## 配置
+### 接口请求配置
+- 如您需要配置的服务支持跨域，可至/src/config/cgi.ts中修改请求链接，请求链接为http://ip:port/path;
+- 如您需要配置的服务不支持跨域，可至vite.config.ts中配置proxy，示例如下：
+
+  ```
+    server: {
+      port: 8080,
+      proxy: {
+        "/solve": {
+          target: "https://example.com",
+          changeOrigin: true,
+        }
+      }
+    }
+  ```
+
+## 知悉
+- 前端服务基于react开发，如需了解react相关知识，可参考：https://react.dev/

frontend/React/index.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title></title>
+  </head>
+
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/index.tsx"></script>
+  </body>
+</html>

frontend/React/package.json

@@ -0,0 +1,49 @@
+{
+	"name": "test-react-flow",
+	"private": true,
+	"version": "0.0.0",
+	"type": "module",
+	"scripts": {
+		"start": "vite --host --mode dev",
+		"build": "tsc && vite build",
+		"preview": "vite preview",
+		"prettier": "prettier --write ."
+	},
+	"devDependencies": {
+		"@babel/plugin-proposal-optional-chaining": "^7.21.0",
+		"@types/classnames": "^2.3.1",
+		"@types/js-cookie": "^3.0.3",
+		"@types/node": "^18.15.11",
+		"@types/react": "^18.0.28",
+		"@types/react-dom": "^18.0.11",
+		"@vitejs/plugin-legacy": "^4.0.2",
+		"@vitejs/plugin-react": "^3.1.0",
+		"husky": "^9.0.11",
+		"less": "^4.1.3",
+		"lint-staged": "^15.2.7",
+		"prettier": "^3.0.0",
+		"react": "^18.2.0",
+		"react-dom": "^18.2.0",
+		"terser": "^5.16.9",
+		"typescript": "^4.9.3",
+		"vite": "^4.2.1",
+		"vite-babel-plugin": "^0.0.2"
+	},
+	"dependencies": {
+		"@antv/x6": "^2.18.1",
+		"@microsoft/fetch-event-source": "^2.0.1",
+		"antd": "^5.18.3",
+		"axios": "^1.3.5",
+		"classnames": "^2.5.1",
+		"elkjs": "^0.9.3",
+		"js-cookie": "^3.0.1",
+		"react-markdown": "^9.0.1",
+		"react-router": "^6.11.2",
+		"react-router-dom": "^6.11.2",
+		"reactflow": "^11.11.3",
+		"rehype-raw": "^7.0.0"
+	},
+	"lint-staged": {
+		"**/*.{ts, tsx, less, module.less, json, md, .html}": "prettier --write ."
+	}
+}

frontend/React/src/App.module.less

@@ -0,0 +1,54 @@
+.app {
+  height: 100%;
+  display: flex;
+  justify-content: space-between;
+  background: url(./assets/background.png) rgb(247, 248, 255);
+  background-size: cover;
+  overflow: hidden;
+}
+
+.content {
+  padding-top: 64px;
+  width: 100%;
+  height: 100%;
+  box-sizing: border-box;
+  // display: flex;
+  // justify-content: center;
+}
+
+.header {
+  position: fixed;
+  padding: 16px 32px;
+  width: 100%;
+  display: flex;
+  align-items: center;
+  box-sizing: border-box;
+
+  &-nav {
+    flex: 1;
+
+    img {
+      height: 40px;
+    }
+
+    a {
+      display: inline-block;
+      text-decoration: none;
+      color: black;
+
+      &:not(:first-of-type) {
+        margin-left: 40px;
+      }
+
+      &.active {
+        font-weight: bold;
+      }
+    }
+  }
+
+  &-opt {
+    flex-shrink: 0;
+    display: flex;
+    align-items: center;
+  }
+}

frontend/React/src/App.tsx

@@ -0,0 +1,23 @@
+import style from "./App.module.less";
+import Logo from "@/assets/logo.svg";
+import { BrowserRouter } from "react-router-dom";
+import RouterRoutes from "@/routes/routes";
+
+function App() {
+  return (
+    <BrowserRouter>
+      <div className={style.app} id="app">
+        <div className={style.header}>
+          <div className={style.headerNav}>
+            <img src={Logo} />
+          </div>
+        </div>
+        <div className={style.content}>
+          <RouterRoutes />
+        </div>
+      </div>
+    </BrowserRouter>
+  );
+}
+
+export default App;

frontend/React/src/components/iconfont/index.tsx

@@ -0,0 +1,7 @@
+import { createFromIconfontCN } from "@ant-design/icons";
+
+const IconFont = createFromIconfontCN({
+  scriptUrl: "//at.alicdn.com/t/c/font_3858115_p8dw9q83s0h.js"
+});
+
+export default IconFont;

frontend/React/src/config/cgi.ts

@@ -0,0 +1,2 @@
+export const mode = import.meta.env.MODE;
+export const GET_SSE_DATA = 'http://127.0.0.1:8002/solve';

frontend/React/src/global.d.ts

@@ -0,0 +1 @@
+declare module 'event-source-polyfill';

frontend/React/src/index.less

@@ -0,0 +1,62 @@
+body,
+html,
+#root {
+  padding: 0;
+  margin: 0;
+  width: 100%;
+  height: 100%;
+  font-family: "PingFang SC";
+  font-size: 14px;
+  line-height: 21px;
+}
+
+#global__message-container {
+  position: fixed;
+  left: 0;
+  right: 0;
+  top: 72px;
+  z-index: 999;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+}
+
+.f {
+  color: #6674D6;
+  font-family: DIN;
+  font-size: 12px;
+  font-style: normal;
+  font-weight: 500;
+  line-height: 14px;
+  position: relative;
+  top: -4px;
+  padding: 0 3px;
+
+  &::after {
+    content: '·';
+    position: absolute;
+    top: 0;
+    right: -2px;
+    color: #6674D6;
+  }
+}
+
+p> :nth-last-child(1).f,
+li> :nth-last-child(1).f {
+  &::after {
+    content: '';
+    opacity: 0;
+  }
+}
+
+.fnn2 {
+  color: #6674D6;
+  font-family: DIN;
+  font-size: 14px;
+  font-style: normal;
+  font-weight: 500;
+  line-height: 14px;
+  position: relative;
+  top: -2px;
+}

frontend/React/src/index.tsx

@@ -0,0 +1,10 @@
+import React from "react";
+import ReactDOM from "react-dom/client";
+import "./index.less";
+import App from "./App";
+
+ReactDOM.createRoot(document.getElementById("root") as HTMLElement).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+);

frontend/React/src/pages/render/index.module.less

@@ -0,0 +1,848 @@
+// inspired by https://www.youtube.com/watch?v=Pl1Gw14pS2I
+.mainPage {
+  display: flex;
+  justify-content: flex-start;
+  align-items: flex-start;
+  padding: 0 60px 60px;
+  height: 100%;
+  overflow: hidden;
+  position: relative;
+  min-width: 1280px;
+  max-width: 1920px;
+  margin: 0 auto;
+
+  .chatContent {
+    position: relative;
+    display: flex;
+    justify-content: flex-start;
+    flex-direction: column;
+    flex-grow: 1;
+    margin-right: 40px;
+    height: calc(100% - 60px);
+    overflow-y: hidden;
+    padding: 32px 0;
+    box-sizing: border-box;
+
+    .top {
+      height: calc(100% - 110px);
+      overflow-y: auto;
+      margin-bottom: 40px;
+    }
+
+    .top::-webkit-scrollbar {
+      width: 6px;
+    }
+
+    .top::-webkit-scrollbar-track {
+      background-color: rgba(255, 255, 255, 0);
+      border-radius: 100px;
+    }
+
+    .top::-webkit-scrollbar-thumb {
+      background-color: rgba(255, 255, 255, 0);
+      border-radius: 100px;
+    }
+
+    .question {
+      display: flex;
+      justify-content: flex-end;
+      margin-bottom: 40px;
+
+      span {
+        padding: 12px 20px;
+        color: #121316;
+        font-size: 14px;
+        line-height: 24px;
+        border-radius: 8px;
+        background: #FFF;
+        max-width: 93.75%;
+      }
+    }
+
+    .end {
+      position: absolute;
+      right: 0;
+      background-color: #fff;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      border-left: 1px solid #D7D8DD;
+      padding-left: 16px;
+
+      .node {
+        position: relative;
+
+        &::before {
+          content: "";
+          border: 1px solid #D7D8DD;
+          border-top: none;
+          border-left: none;
+          width: calc(16px - 2px);
+          height: 0px;
+          position: absolute;
+          left: -16px;
+          top: 50%;
+          // transform: translateY(-50%);
+        }
+
+        article {
+          padding: 8px 16px;
+          border-radius: 8px;
+          border: 1px solid transparent;
+          color: #4082FE;
+          text-align: center;
+          font-size: 14px;
+          line-height: 24px;
+          box-sizing: border-box;
+          background: rgba(232, 233, 249);
+          color: #2126C0;
+        }
+      }
+    }
+
+    .answer {
+      border-radius: 8px;
+      background: rgba(33, 38, 192, 0.10);
+      padding: 12px;
+
+      .inner {
+        width: 100%;
+        background-color: #fff;
+        border-radius: 4px;
+        padding: 8px;
+        box-sizing: border-box;
+        transition: all 0.5s ease;
+        margin-bottom: 18px;
+
+        .mapArea {
+          width: 100%;
+          overflow-x: auto;
+          overflow-y: hidden;
+
+          &::-webkit-scrollbar {
+            height: 6px;
+          }
+
+          &::-webkit-scrollbar-track {
+            background-color: rgba(255, 255, 255, 0);
+            border-radius: 10px;
+          }
+
+          &::-webkit-scrollbar-thumb {
+            background-color: #d7d8dd;
+            border-radius: 100px;
+          }
+        }
+
+      }
+
+
+      .response {
+        color: #121316;
+        font-size: 14px;
+        line-height: 24px;
+        padding: 18px 42px;
+
+        h3 {
+          font-size: 24px;
+          font-weight: 600;
+          line-height: 36px;
+          margin: 0 0 16px 0;
+        }
+
+        h4 {
+          font-size: 20px;
+          font-weight: 600;
+          line-height: 30px;
+          margin: 0 0 8px 0;
+        }
+
+        p {
+          color: rgba(18, 19, 22, 0.80);
+          font-size: 16px;
+          font-weight: 400;
+          line-height: 28px;
+          margin: 0 0 16px 0;
+        }
+
+        ul {
+          margin-bottom: 8px;
+          padding-left: 22px;
+        }
+
+        li {
+          color: rgba(18, 19, 22, 0.80);
+          font-size: 16px;
+          font-weight: 400;
+          line-height: 28px;
+
+          p {
+            margin-bottom: 4px;
+          }
+        }
+      }
+    }
+
+    .sendArea {
+      display: flex;
+      width: 100%;
+      box-sizing: border-box;
+      padding: 10px 12px 10px 24px;
+      justify-content: space-between;
+      align-items: center;
+      border-radius: 8px;
+      border: 2px solid var(--fill-5, #464A53);
+      background: #FFF;
+      position: relative;
+
+      :global {
+        .ant-input {
+          &:focus {
+            box-shadow: none !important;
+            outline: 0 !important;
+          }
+        }
+      }
+
+      input {
+        height: 36px;
+        line-height: 36px;
+        flex-grow: 1;
+        border: 0;
+        outline: 0;
+
+        &:focus {
+          border: 0;
+          outline: 0;
+        }
+      }
+
+      button {
+        display: flex;
+        justify-content: flex-start;
+        align-items: center;
+        border: 0;
+        background-color: #fff;
+        cursor: pointer;
+        padding: 8px;
+        width: 65px;
+        flex-shrink: 0;
+
+        img {
+          margin-right: 4px;
+        }
+      }
+    }
+
+    .notice {
+      color: #12131659;
+      padding-top: 8px;
+      text-align: center;
+      font-weight: 400;
+
+      a {
+        text-decoration: none;
+        color: #444;
+        display: inline-flex;
+        align-items: center;
+
+        span {
+          font-size: 18px;
+        }
+      }
+    }
+  }
+
+  .progressContent {
+    width: 44.44%;
+    flex-shrink: 0;
+    box-sizing: border-box;
+    padding: 24px;
+    border-radius: 8px;
+    border: rgba(33, 38, 192, 0.10);
+    background: rgba(255, 255, 255, 0.80);
+    height: calc(100% - 60px);
+    overflow-y: auto;
+    position: relative;
+
+    &::-webkit-scrollbar {
+      width: 6px;
+    }
+
+    &::-webkit-scrollbar-track {
+      background-color: rgba(255, 255, 255, 0);
+      border-radius: 100px;
+    }
+
+    &::-webkit-scrollbar-thumb {
+      background-color: rgba(255, 255, 255, 0);
+      border-radius: 100px;
+    }
+
+    .toggleIcon {
+      position: absolute;
+      right: 24px;
+      top: 28px;
+      cursor: pointer;
+    }
+
+    .titleNode {
+      color: #121316;
+      font-size: 24px;
+      font-weight: 600;
+      line-height: 36px;
+      margin-bottom: 24px;
+    }
+
+    .conclusion {
+      padding-top: 8px;
+      color: #121316;
+      font-size: 14px;
+      line-height: 24px;
+
+      ul {
+        padding-left: 24px;
+      }
+    }
+
+    .steps {
+      .title {
+        color: var(--100-text-5, #121316);
+        font-size: 20px;
+        font-weight: 600;
+        line-height: 30px;
+        display: flex;
+        justify-content: flex-start;
+        align-items: center;
+        position: relative;
+
+        .open {
+          position: absolute;
+          right: 0;
+          font-size: 20px;
+          font-weight: normal;
+
+          span {
+            color: #121316;
+            opacity: 0.6;
+          }
+        }
+
+        i {
+          width: 12px;
+          height: 12px;
+          border-radius: 50%;
+          background-color: #2126C0;
+          margin-right: 8px;
+        }
+      }
+
+      &.thinking,
+      &.select {
+        margin-bottom: 24px;
+      }
+
+      &.select {
+        .searchList {
+          margin-top: 0 !important;
+          border-radius: 8px;
+          background: var(--fill-2, #F4F5F9);
+          padding: 8px;
+        }
+      }
+
+      .con {
+        margin-left: 5px;
+        padding-top: 8px;
+        padding-left: 15px;
+        border-left: 1px solid rgba(33, 38, 192, 0.20);
+        height: auto;
+
+        &.collapsed {
+          overflow: hidden;
+          height: 0;
+          padding-top: 0;
+          transition: all 1s;
+        }
+
+        .subTitle {
+          color: var(--100-text-5, #121316);
+          font-size: 14px;
+          font-weight: 600;
+          line-height: 24px;
+          margin-bottom: 4px;
+
+          span {
+            margin-right: 4px;
+          }
+        }
+
+        .query,
+        >.searchList {
+          margin-top: 24px;
+          // margin-bottom: 24px;
+        }
+
+        .query {
+          &-Item {
+            display: inline-flex;
+            padding: 4px 8px;
+            margin-right: 4px;
+            margin-bottom: 4px;
+            border-radius: 4px;
+            border: 1px solid #EBECF0;
+            color: rgba(18, 19, 22, 0.80);
+            font-size: 14px;
+            line-height: 24px;
+            height: 32px;
+            box-sizing: border-box;
+            overflow: hidden;
+            // animation: fadeIn linear 2s;
+          }
+        }
+
+        .searchList {
+          .thought {
+            color: rgba(18, 19, 22, 0.80);
+            font-size: 14px;
+            line-height: 24px;
+            margin-bottom: 16px;
+          }
+
+          .scrollCon {
+            padding-right: 6px;
+            max-height: 300px;
+            overflow-y: auto;
+            position: relative;
+          }
+
+          .scrollCon::-webkit-scrollbar {
+            width: 6px;
+          }
+
+          .scrollCon::-webkit-scrollbar-track {
+            background-color: rgba(255, 255, 255, 0);
+            border-radius: 100px;
+          }
+
+          .scrollCon::-webkit-scrollbar-thumb {
+            background-color: #d7d8dd;
+            border-radius: 100px;
+          }
+
+          .inner {
+            width: 100%;
+            border-radius: 8px;
+            background: var(--fill-2, #F4F5F9);
+            transition: all 0.5s ease;
+            box-sizing: border-box;
+            padding: 8px;
+          }
+
+          .searchItem {
+            border-radius: 8px;
+            background: var(---fill-0, #FFF);
+            margin-bottom: 6px;
+            padding: 4px 8px;
+            transition: all 0.5s ease-in-out;
+
+            &.highLight {
+              border: 1px solid var(---Success-6, #00B365);
+              background: linear-gradient(0deg, rgba(218, 242, 228, 0.40) 0%, rgba(218, 242, 228, 0.40) 100%), #FFF;
+            }
+
+            p {
+              white-space: nowrap;
+              max-width: 95%;
+              overflow: hidden;
+              text-overflow: ellipsis;
+              margin: 0;
+            }
+
+            p.summ {
+              color: rgba(18, 19, 22, 0.80);
+              font-size: 13px;
+              line-height: 20px;
+              margin-bottom: 2px;
+            }
+
+            p.url {
+              color: var(--60-text-3, rgba(18, 19, 22, 0.60));
+              font-size: 12px;
+              line-height: 18px;
+              padding-left: 20px;
+            }
+          }
+        }
+
+
+      }
+    }
+  }
+}
+
+pre {
+  margin: 0;
+  padding-top: 8px;
+  color: #121316;
+  font-size: 14px;
+  line-height: 24px;
+  font-family: 'PingFang SC', 'Franklin Gothic Medium', 'Arial Narrow', Arial, sans-serif;
+  white-space: wrap;
+}
+
+ul {
+  margin: 0;
+  padding: 0;
+}
+
+.draft {
+  width: 100%;
+  white-space: wrap;
+  // display: flex;
+  // justify-content: flex-start;
+  // align-items: flex-start;
+  position: relative;
+
+  .loading,
+  .loading>div {
+    position: relative;
+    box-sizing: border-box;
+  }
+
+  .loading {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    font-size: 0;
+    color: #fff;
+    background-color: #f90;
+    width: 20px;
+    height: 20px;
+    border-radius: 50%;
+    margin-right: 3px;
+    flex-shrink: 0;
+    position: absolute;
+    top: 0;
+    left: 0;
+  }
+
+  .loading>div {
+    display: inline-block;
+    float: none;
+    background-color: currentColor;
+    border: 0 solid currentColor;
+  }
+
+  .loading>div:nth-child(1) {
+    animation-delay: -200ms;
+  }
+
+  .loading>div:nth-child(2) {
+    animation-delay: -100ms;
+  }
+
+  .loading>div:nth-child(3) {
+    animation-delay: 0ms;
+  }
+
+  .loading>div {
+    width: 3px;
+    height: 3px;
+    margin: 2px 1px;
+    border-radius: 100%;
+    animation: ball-pulse 1s ease infinite;
+  }
+}
+
+.mindmap {
+  position: relative;
+
+  article {
+    padding: 6px 16px;
+    border-radius: 8px;
+    height: 38px;
+    border: 1px solid transparent;
+    background: #FFF;
+    color: #121316;
+    text-align: center;
+    font-size: 14px;
+    line-height: 24px;
+    position: relative;
+    box-sizing: border-box;
+
+    &.loading {
+      line-height: 20px;
+      border-radius: 8px;
+      overflow: hidden;
+      border: 1px solid transparent;
+      padding: 4px;
+
+      span {
+        color: #2126C0;
+        background-color: #fff;
+        border-radius: 4px;
+        line-height: 24px;
+        padding: 2px 12px;
+      }
+
+      .looping {
+        --border-width: 4px;
+        --follow-panel-linear-border: linear-gradient(91deg,
+            #5551FF 0.58%,
+            #FF87DE 100.36%);
+
+        position: absolute;
+        top: 0;
+        left: 0;
+        width: calc(100% + var(--border-width) * 2 - 8px);
+        height: calc(100%);
+        background: var(--follow-panel-linear-border);
+        background-size: 300% 300%;
+        background-position: 0 50%;
+        animation: moveGradient 4s alternate infinite;
+      }
+    }
+
+    &.disabled {
+      border-radius: 8px;
+      border: 1px solid #D7D8DD;
+      color: rgba(18, 19, 22, 0.35);
+    }
+
+    &.finished {
+      // cursor: pointer;
+      border: 1px solid #2126C0;
+
+      .finishDot {
+        position: absolute;
+        top: 6px;
+        right: 6px;
+        width: 6px;
+        height: 6px;
+        background-color: #C9C0FE;
+        border-radius: 50%;
+      }
+    }
+
+    &.init {
+      border: 1px solid transparent;
+      cursor: auto;
+    }
+
+    span {
+      display: block;
+      white-space: nowrap;
+      max-width: 160px;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      position: relative;
+      z-index: 20;
+    }
+
+    span.status {
+      color: #4082FE;
+    }
+
+  }
+
+  // 第一个article，起始节点
+  >li {
+    >article {
+      border-radius: 8px;
+      background: rgba(33, 38, 192, 0.10);
+      color: #2126C0;
+    }
+  }
+
+  li {
+    list-style: none;
+    display: flex;
+    align-items: center;
+    box-sizing: border-box;
+    margin: 16px;
+    line-height: 1;
+    position: relative;
+
+    &>ul.onlyone {
+      &:before {
+        opacity: 0;
+      }
+
+      >li {
+        margin-left: 0px;
+      }
+
+      &>li:after {
+        opacity: 0;
+      }
+
+      &>li:before {
+        // left: 0;
+      }
+    }
+
+    &>ul:before {
+      content: "";
+      border: 1px solid #D7D8DD;
+      border-top: none;
+      border-left: none;
+      width: calc(16px - 2px);
+      height: 0px;
+      position: absolute;
+      left: 0;
+      top: 50%;
+      // transform: translateY(-50%);
+    }
+
+    &:before {
+      content: "";
+      border: 1px solid #D7D8DD;
+      border-top: none;
+      border-left: none;
+      width: 16px;
+      height: 0px;
+      position: absolute;
+      left: calc(-16px - 1px);
+    }
+
+    &:after {
+      content: "";
+      border: 1px solid #D7D8DD;
+      border-top: none;
+      border-left: none;
+      width: 0px;
+      height: calc(100% / 2 + 33px);
+      position: absolute;
+      left: calc(-16px - 2px);
+    }
+
+    &:first-of-type:after {
+      top: 50%;
+    }
+
+    &:last-of-type:after {
+      bottom: 50%;
+    }
+
+    ul {
+      padding: 0 0 0 16px;
+      position: relative;
+    }
+  }
+
+  &>li {
+
+    &:after,
+    &:before {
+      display: none;
+    }
+  }
+
+  .endLine {
+    border-bottom: 1px solid #D7D8DD;
+    width: 3000px;
+    transition: width 1s ease-in-out;
+  }
+}
+
+.showRight {
+  position: fixed;
+  top: 80px;
+  right: -10px;
+  width: 42px;
+  cursor: pointer;
+
+  img {
+    width: 100%;
+  }
+}
+
+@keyframes ball-pulse {
+
+  0%,
+  60%,
+  100% {
+    opacity: 1;
+    transform: scale(1);
+  }
+
+  30% {
+    opacity: 0.1;
+    transform: scale(0.01);
+  }
+}
+
+@keyframes moveGradient {
+  50% {
+    background-position: 100% 50%;
+  }
+}
+
+@keyframes fadeIn {
+  0% {
+    width: 0;
+    opacity: 0;
+  }
+
+  100% {
+    width: auto;
+    opacity: 1;
+  }
+}
+
+@keyframes unfold {
+  0% {
+    height: auto;
+  }
+
+  100% {
+    height: 0;
+  }
+}
+
+
+.loading99 {
+  margin: 20px;
+  position: relative;
+  width: 1px;
+  height: 1px;
+}
+
+.loading99:before,
+.loading99:after {
+  position: absolute;
+  display: inline-block;
+  width: 15px;
+  height: 15px;
+  content: "";
+  border-radius: 100%;
+  background-color: #5551FF;
+}
+
+.loading99:before {
+  left: -15px;
+  animation: ball-pulse infinite 0.75s -0.4s cubic-bezier(0.2, 0.68, 0.18, 1.08);
+}
+
+.loading99:after {
+  right: -15px;
+  animation: ball-pulse infinite 0.75s cubic-bezier(0.2, 0.68, 0.18, 1.08);
+}
+
+@keyframes ball-pulse {
+  0% {
+    transform: scale(1);
+    opacity: 1;
+  }
+
+  50% {
+    transform: scale(0.1);
+    opacity: 0.6;
+  }
+
+  100% {
+    transform: scale(1);
+    opacity: 1;
+  }
+}

frontend/React/src/pages/render/index.tsx

@@ -0,0 +1,681 @@
+import styles from './index.module.less';
+import { useEffect, useState, useRef, Children } from 'react';
+import MindMapItem from './mindMapItem';
+import PackIcon from '@/assets/pack-up.svg';
+import SendIcon from '@/assets/sendIcon.svg';
+import { Tooltip, Input, message } from 'antd';
+import IconFont from '@/components/iconfont';
+import ReactMarkdown from "react-markdown";
+import ShowRightIcon from "@/assets/show-right-icon.png";
+import rehypeRaw from 'rehype-raw';
+import classNames from 'classnames';
+import { fetchEventSource } from '@microsoft/fetch-event-source';
+import { GET_SSE_DATA } from '@/config/cgi';
+import { replaceStr } from '@/utils/tools';
+
+const RenderTest = () => {
+  let eventSource: any = null;
+  let sseTimer: any = useRef(null);
+  const [isWaiting, setIsWaiting] = useState(false);
+  const [question, setQuestion] = useState("");
+  const [stashQuestion, setStashQuestion] = useState("");
+  const [isEnd, setIsEnd] = useState(false);
+  const [showEndNode, setShowEndNode] = useState(false);
+  // 一组节点的渲染草稿
+  const [draft, setDraft] = useState('');
+  // 一轮完整对话结束
+  const [chatIsOver, setChatIsOver] = useState(true);
+  // 一组节点的思考草稿是不是打印结束
+  const [draftEnd, setDraftEnd] = useState(false);
+
+  const [progress1, setProgress1] = useState('');
+  const [progress2, setProgress2] = useState('');
+  const [progressEnd, setProgressEnd] = useState(false);
+
+  const [conclusion, setConclusion] = useState('');
+  const [stashConclusion, setstashConclusion] = useState('');
+
+  const [query, setQuery] = useState([]);
+  const [searchList, setSearchList] = useState([]);
+  // 整体的渲染树
+  const [renderData, setRenderData] = useState<any[]>([]);
+  const [currentNode, setCurrentNode] = useState<any>(null);
+  // 渲染minddata里的第几个item
+  const [renderIndex, setRenderIndex] = useState<number>(0);
+  const [response, setResponse] = useState("");
+  const [currentStep, setCurrentStep] = useState(0);
+  // steps展开收起的信息
+  const [collapseInfo, setCollapseInfo] = useState([true, true]);
+  const [mapWidth, setMapWidth] = useState(0);
+  // 是否展示右侧内容
+  const [showRight, setShowRight] = useState(true);
+
+  const [currentNodeRendering, setCurrentNodeRendering] = useState(false);
+  const [selectedIds, setSelectedIds] = useState([]);
+  const [nodeName, setNodeName] = useState('');
+  const hasHighlight = useRef(false);
+  const conclusionRender = useRef(false);
+  const nodeDraftRender = useRef(false);
+  const [obj, setObj] = useState<any>(null);
+  const [nodeOutputEnd, setNodeEnd] = useState(false);
+  const [adjList, setAdjList] = useState([]);
+
+  const TEXT_INTERVAL = 20;
+  const SEARCHLIST_INTERVAL = 80;
+
+
+  const toggleRight = () => {
+    setShowRight(!showRight);
+  };
+
+  const findAndUpdateStatus = (nodes: any[], targetNode: any) => {
+    return nodes.map((node) => {
+      if (node.state === 1 && node.id !== 0) {
+        return { ...node, state: 3 };
+      }
+
+      if (node.name === targetNode) {
+        return { ...node, state: 1 };
+      }
+
+      if (node.children) {
+        // 递归地在子节点中查找
+        node.children = findAndUpdateStatus(node.children, targetNode);
+      }
+
+      return node;
+    });
+  }
+
+  const generateEndStyle = () => {
+    // 获取所有class为endline的div元素
+    const endlineDivs = document.getElementsByClassName('endline');
+    const mindMap = document.getElementById("mindMap");
+    // 确保至少有两个元素
+    if (endlineDivs.length >= 2 && mindMap) {
+      // 获取第一个和最后一个元素的边界框（bounding rectangle）
+      const firstRect = endlineDivs[0].getBoundingClientRect();
+      const lastRect = endlineDivs[endlineDivs.length - 1].getBoundingClientRect();
+      const mindMapRect = mindMap?.getBoundingClientRect();
+      // 计算y值的差值
+      const yDiff = lastRect.top - firstRect.top;
+      // const top = firstRect.top - mindMapRect.top;
+      // 如果需要包含元素的完整高度（不仅仅是顶部位置），可以加上元素的高度
+      // const yDiffWithHeight = yDiff + (lastRect.height - firstRect.height);
+      return {
+        top: firstRect.top - mindMapRect.top,
+        height: yDiff + 1
+      };
+    } else {
+      return {
+        top: '50%',
+        height: 0
+      };
+    }
+  };
+
+  const generateWidth = () => {
+    const articles = document.querySelectorAll('article');
+    // 确保至少有两个元素
+    if (articles?.length) {
+      let maxRight = 0;
+      articles.forEach((item, index) => {
+        if (item.getBoundingClientRect().right > maxRight) {
+          maxRight = item.getBoundingClientRect().right;
+        }
+      })
+      const firstArticle = articles[0].getBoundingClientRect();
+      if (maxRight - firstArticle.left + 200 > mapWidth) {
+        return maxRight - firstArticle.left + 200
+      } else {
+        return mapWidth;
+      }
+    } else {
+      return 100;
+    }
+  };
+
+  // 逐字渲染
+  const renderDraft = (str: string, type: string, endCallback: () => void) => {
+    // 已经输出的字符数量
+    let outputIndex = 0;
+
+    // 输出字符的函数
+    const outputText = () => {
+      // 给出高亮后draft输出的结束标志
+      if (type === 'stepDraft-1' && outputIndex + 3 > str?.length) {
+        nodeDraftRender.current = true;
+      }
+      // 如果还有字符未输出
+      if (outputIndex < str?.length) {
+        // 获取接下来要输出的1个字符（或剩余字符，如果不足3个）
+        let chunk = str.slice(outputIndex, Math.min(outputIndex + 10, str.length));
+        // 更新已输出字符的索引
+        outputIndex += chunk.length;
+        if (type === 'thought') {
+          setDraft(str.slice(0, outputIndex));
+        } else if (type === "stepDraft-0") {
+          setProgress1(str.slice(0, outputIndex));
+        } else if (type === "stepDraft-1") {
+          setProgress2(str.slice(0, outputIndex));
+        } else if (type === "conclusion") {
+          setConclusion(str.slice(0, outputIndex));
+        } else if (type === "response") {
+          setResponse(str.slice(0, outputIndex));
+        }
+      } else {
+        // 如果没有更多字符需要输出，则清除定时器
+        clearInterval(intervalId);
+        endCallback && endCallback()
+      }
+    }
+
+    // 设定定时器ID
+    let intervalId = setInterval(outputText, TEXT_INTERVAL);
+  }
+
+  // 渲染搜索结果renderSearchList
+  const renderSearchList = () => {
+    let outputIndex = 0;
+    const content = JSON.parse(currentNode.actions[currentStep].result[0].content);
+
+    const arr: any = Object.keys(content).map(item => {
+      return { id: item, ...content[item] };
+    });
+    const len = Object.keys(content).length;
+    const outputText = () => {
+      outputIndex++;
+      if (outputIndex < len + 1) {
+        setSearchList(arr.slice(0, outputIndex));
+      } else {
+        clearInterval(intervalId);
+      }
+    };
+    // 设定定时器ID
+    let intervalId = setInterval(outputText, SEARCHLIST_INTERVAL);
+  };
+
+  // 高亮searchList
+  const highLightSearchList = (ids: any) => {
+    setSelectedIds([]);
+    const newStep = currentStep + 1;
+    setCurrentStep(newStep);
+    const highlightArr: any = [...searchList];
+    highlightArr.forEach((item: any) => {
+      if (ids.includes(Number(item.id))) {
+        item.highLight = true;
+      }
+    })
+    highlightArr.sort((item1: any, item2: any) => {
+      if (item1.highLight === item2.highLight) {
+        return 0;
+      }
+      // 如果item1是highlight，放在前面
+      if (item1.highLight) {
+        return -1;
+      }
+      // 如果item2是highlight，放在后面
+      return 1;
+    })
+    setSearchList(highlightArr);
+    renderDraft(currentNode.actions[1].thought, `stepDraft-1`, () => { });
+    hasHighlight.current = true; // 标记为高亮已执行
+  };
+
+  // 渲染结论
+  const renderConclusion = () => {
+    const res = window.localStorage.getItem('nodeRes') || '';
+    const replaced = replaceStr(res);
+    // setTimeout(() => { setCollapseInfo([false, false]); }, 2000);
+    setCollapseInfo([false, false]);
+    setConclusion(replaced);
+    setstashConclusion(res);
+    // 给出conclusion结束的条件
+    if (stashConclusion.length + 5 > res.length) {
+      conclusionRender.current = true;
+      setProgressEnd(true);
+    }
+  };
+
+  // 渲染query
+  const renderQuery = (endCallback: () => void) => {
+    const queries = currentNode.actions[currentStep]?.args?.query;
+    setQuery(queries);
+    endCallback && endCallback();
+  };
+
+  const renderSteps = () => {
+    setCurrentNodeRendering(true);
+    const queryEndCallback = () => {
+      if (currentNode.actions[currentStep].result[0].content) {
+        if (currentNode.actions[currentStep].type === "BingBrowser.search" || currentNode.actions[currentStep].type === "BingBrowser") {
+          renderSearchList();
+        }
+      }
+    };
+    const thoughtEndCallback = () => {
+      if (currentNode.actions[currentStep]?.args?.query?.length) {
+        renderQuery(queryEndCallback);
+      } else {
+        queryEndCallback();
+      }
+    };
+    if (currentNode.actions[currentStep].thought) {
+      renderDraft(currentNode.actions[currentStep].thought, `stepDraft-${currentStep}`, thoughtEndCallback);
+    }
+  }
+
+  // 展开收起
+  const toggleCard = (index: number) => {
+    const arr = [...collapseInfo];
+    arr[index] = !arr[index];
+    setCollapseInfo(arr);
+  };
+
+  // 渲染过程中保持渲染文字可见
+  const keepScrollTop = (divA: any, divB: any) => {
+    // 获取 divB 的当前高度
+    const bHeight = divB.offsetHeight;
+
+    // 检查 divA 是否需要滚动（即 divB 的高度是否大于 divA 的可视高度）
+    if (bHeight > divA.offsetHeight) {
+      // 滚动到 divB 的底部在 divA 的可视区域内
+      divA.scrollTop = bHeight - divA.offsetHeight;
+    }
+  };
+
+  useEffect(() => {
+    setRenderData([
+      {
+        id: 0,
+        state: 3,
+        name: '原始问题',
+        children: adjList
+      }
+    ])
+  }, [JSON.stringify(adjList)]);
+
+  useEffect(() => {
+    console.log('render data changed-----', renderData);
+  }, [renderData]);
+
+  useEffect(() => {
+    if (currentStep === 1) {
+      setCollapseInfo([false, true]);
+    }
+  }, [currentStep]);
+
+  useEffect(() => {
+    if (nodeOutputEnd && !localStorage.getItem('nodeRes')) {
+      // 如果节点输出结束了，但是response还没有结束，认为节点渲染已结束
+      conclusionRender.current = true;
+      setProgressEnd(true);
+      return;
+    }
+    if (nodeDraftRender.current && localStorage.getItem('nodeRes')) {
+      renderConclusion();
+    }
+  }, [localStorage.getItem('nodeRes'), nodeDraftRender.current, nodeOutputEnd]);
+
+  useEffect(() => {
+    if (obj?.response?.nodes[obj.current_node]?.detail?.state !== 1) {
+      setIsWaiting(true);
+    }
+    if (obj?.response?.nodes?.[obj.current_node].detail?.state === 0 && currentNode?.current_node === obj.current_node) {
+      console.log('node render end-----', obj);
+      setNodeEnd(true);
+    }
+
+    if (obj?.current_node && obj?.response?.state === 3) {
+      // 当node节点的数据可以开始渲染时，给currentnode赋值
+      // update conclusion
+      if (obj.response.nodes[obj.current_node]?.detail?.actions?.length === 2 &&
+        obj.response.nodes[obj.current_node]?.detail?.state === 1 &&
+        obj.response.nodes[obj.current_node]?.detail.response) {
+        window.localStorage.setItem('nodeRes', obj.response.nodes[obj.current_node]?.detail.response);
+      }
+      if (obj.current_node &&
+        (obj.response.nodes[obj.current_node]?.detail?.state === 1) &&
+        obj.response.nodes[obj.current_node]?.detail?.actions?.length &&
+        currentStep === 0 &&
+        currentNode?.current_node !== obj?.current_node
+      ) {
+        // 更新当前渲染节点
+        console.log('update current node----');
+        setIsWaiting(false);
+        setCurrentNode({ ...obj.response.nodes[obj.current_node]?.detail, current_node: obj.current_node });
+      }
+
+      // 设置highlight
+      if (!selectedIds.length &&
+        obj.response.nodes[obj.current_node]?.detail?.actions?.[1]?.type === 'BingBrowser.select' &&
+        (obj.response.nodes[obj.current_node]?.detail?.state === 1)) {
+        setSelectedIds(obj.response.nodes[obj.current_node]?.detail?.actions?.[1]?.args?.select_ids || []);
+        setCurrentNode({ ...obj.response.nodes[obj.current_node]?.detail, current_node: obj.current_node });
+      }
+    }
+  }, [obj]);
+
+  useEffect(() => {
+    // 输出思考过程
+    if (!currentNode || currentNodeRendering) { return; }
+    renderSteps();
+  }, [currentNode, currentNodeRendering, selectedIds]);
+
+  useEffect(() => {
+    if (!hasHighlight.current && selectedIds.length && currentNode?.actions.length === 2) {
+      // 渲染高亮的search信息
+      highLightSearchList(selectedIds);
+    }
+  }, [selectedIds, currentNode]);
+
+  useEffect(() => {
+    // 当前节点渲染结束
+    if (nodeName && nodeName !== currentNode?.current_node && progressEnd && !isEnd) {
+      resetNode(nodeName);
+      setMapWidth(generateWidth());
+    }
+  }, [nodeName, currentNode, progressEnd, isEnd]);
+
+  let responseTimer: any = useRef(null);
+  useEffect(() => {
+    if (isEnd) {
+      responseTimer.current = setInterval(() => {
+        const divA = document.getElementById('chatArea') as HTMLDivElement;
+        const divB = document.getElementById('messageWindowId') as HTMLDivElement;
+        keepScrollTop(divA, divB);
+        if (chatIsOver) {
+          clearInterval(responseTimer.current);
+        }
+      }, 500);
+      setTimeout(() => {
+        setShowEndNode(true);
+      }, 300);
+    } else if (responseTimer.current) {
+      // 如果 isEnd 变为 false，清除定时器
+      clearInterval(responseTimer.current);
+      responseTimer.current = null;
+    }
+
+    // 返回清理函数，确保组件卸载时清除定时器
+    return () => {
+      if (responseTimer.current) {
+        clearInterval(responseTimer.current);
+        responseTimer.current = null;
+      }
+    };
+  }, [isEnd, chatIsOver]);
+
+  useEffect(() => {
+    setRenderData([]);
+    setResponse('');
+    setDraft('');
+    setIsEnd(false);
+    setShowRight(true);
+    window.localStorage.setItem('nodeRes', '');
+    window.localStorage.setItem('finishedNodes', '');
+  }, [question]);
+
+  const resetNode = (targetNode: string) => {
+    if (targetNode === 'response') return; // 如果开始response了，所有节点都渲染完了，不需要reset
+    // 渲染下一个节点前，初始化状态
+    const newData = findAndUpdateStatus(renderData, targetNode);
+    console.log('reset node------', targetNode, renderData);
+    setCurrentStep(0);
+    setQuery([]);
+    setSearchList([]);
+    setConclusion('');
+    setCollapseInfo([true, true]);
+    setProgress1('');
+    setProgress2('');
+    setProgressEnd(false);
+    setCurrentNode(null);
+    setCurrentNodeRendering(false);
+    setSelectedIds([]);
+    setNodeEnd(false);
+    hasHighlight.current = false;
+    nodeDraftRender.current = false;
+    conclusionRender.current = false;
+    window.localStorage.setItem('nodeRes', '');
+  };
+
+  const formatData = (data: any) => {
+    try {
+      setIsWaiting(false);
+      const obj = JSON.parse(data);
+      if (!obj.current_node && obj.response.state === 0) {
+        console.log('chat is over end-------');
+        setChatIsOver(true);
+        return;
+      }
+      if (!obj.current_node && obj.response.state === 9) {
+        setShowRight(false);
+        setIsEnd(true);
+        const replaced = replaceStr(obj.response.response);
+        setResponse(replaced);
+        return;
+      }
+      if (!obj.current_node && obj.response.state === 1 && !currentNode) {
+        // 有thought，没有node
+        setDraftEnd(false);
+        setDraft(obj.response.response);
+      }
+      if (!obj.current_node && (obj.response.state !== 1 || obj.response.state !== 0 || obj.response.state !== 9)) {
+        // 有thought，没有node, 不用处理渲染
+        //console.log('loading-------------', obj);
+        setDraftEnd(true);
+        setIsWaiting(true);
+      }
+      if (obj.current_node && obj.response.state === 3) {
+        setNodeName(obj.current_node);
+        // 有node
+        setObj(obj);
+        const newAdjList = obj.response?.adjacency_list;
+        if (newAdjList?.length > 0) {
+          setAdjList(newAdjList);
+        }
+      }
+    } catch (err) {
+      console.log('format error-----', err);
+    }
+  };
+
+  const startEventSource = () => {
+    if (!chatIsOver) {
+      message.warning('有对话进行中！');
+      return;
+    }
+    setQuestion(stashQuestion);
+    setChatIsOver(false);
+    const postData = {
+      inputs: [
+        {
+          role: 'user',
+          content: stashQuestion
+        }
+      ]
+    }
+    const ctrl = new AbortController();
+    eventSource = fetchEventSource(GET_SSE_DATA, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(postData),
+      onmessage(ev) {
+        formatData(ev.data);
+      },
+      onerror(err) {
+        console.log('sse error------', err);
+      },
+      // signal: ctrl.signal,
+    });
+  };
+
+  const abortEventSource = () => {
+    if (eventSource) {
+      eventSource.close(); // 或使用其他方法关闭连接，具体取决于库的API
+      eventSource = null;
+      console.log('EventSource connection aborted due to timeout.');
+      message.error('连接中断，2s后即将刷新页面---');
+      setTimeout(() => {
+        location.reload();
+      }, 2000);
+    }
+  };
+
+  return <div className={styles.mainPage} style={!showRight ? { maxWidth: '1000px' } : {}}>
+    <div className={styles.chatContent}>
+      <div className={styles.top} id="chatArea">
+        <div id="messageWindowId">
+          {
+            question && <div className={styles.question}>
+              <span>{question}</span>
+            </div>
+          }
+          {
+            (draft || response || renderData?.length > 0) &&
+            <div className={styles.answer}>
+              {
+                renderData?.length > 0 ? <div className={styles.inner}>
+                  <div className={styles.mapArea}>
+                    <ul className={styles.mindmap} id="mindMap" style={isEnd ? { width: mapWidth, overflow: "hidden" } : {}}>
+                      {renderData.map((item: any) => (
+                        <MindMapItem key={item.name} item={item} isEnd={isEnd} />
+                      ))}
+                      {showEndNode &&
+                        <div className={styles.end} style={generateEndStyle()}>
+                          <div className={styles.node}>
+                            <article>最终回复</article>
+                          </div>
+                        </div>
+                      }
+                    </ul>
+                  </div>
+                </div> : <></>
+              }
+              {
+                !response && <div className={styles.draft}>
+                  {/* {!draftEnd && draft && <div className={styles.loading}>
+                    <div></div>
+                    <div></div>
+                    <div></div>
+                  </div>} */}
+                  <ReactMarkdown rehypePlugins={[rehypeRaw]}>{replaceStr(draft)}</ReactMarkdown>
+                </div>
+              }
+              {response && <div className={styles.response}>
+                <ReactMarkdown rehypePlugins={[rehypeRaw]}>{response}</ReactMarkdown>
+              </div>}
+            </div>
+          }
+        </div>
+      </div>
+      <div className={styles.sendArea}>
+        <Input type="text" placeholder='说点什么吧~  Shift+Enter 换行 ； Enter 发送' onChange={(e) => { setStashQuestion(e.target.value) }}
+          onPressEnter={startEventSource} />
+        <button onClick={startEventSource}>
+          <img src={SendIcon} />
+          发送
+        </button>
+      </div>
+      <div className={styles.notice}>如果想要更丝滑的体验，请在本地搭建-<a href='https://github.com/InternLM/MindSearch' target='_blank'>MindSearch <IconFont type='icon-GithubFilled' /></a></div>
+    </div>
+    {showRight && <div className={styles.progressContent}>
+      {
+        currentNode && <>
+          <div className={styles.toggleIcon} onClick={toggleRight}>
+            <Tooltip placement="top" title="收起">
+              <img src={PackIcon} />
+            </Tooltip></div>
+          <div className={styles.titleNode}>{currentNode?.content || currentNode?.node}</div>
+          {
+            currentNode?.actions?.length ? <>
+              {
+                currentNode.actions.map((item: any, idx: number) => (
+                  currentStep >= idx && <div className={classNames(
+                    styles.steps,
+                    item.type === "BingBrowser.search" ? styles.thinking : styles.select
+                  )} key={`step-${idx}`}>
+                    <div className={styles.title}>
+                      <i></i>{item.type === "BingBrowser.search" ? "思考" : item.type === "BingBrowser.select" ? "信息来源" : "信息整合"}
+                      <div className={styles.open} onClick={() => { toggleCard(idx) }}>
+                        <IconFont type={collapseInfo[idx] ? "icon-shouqi" : "icon-xiangxiazhankai"} />
+                      </div>
+                    </div>
+                    <div className={classNames(
+                      styles.con,
+                      !collapseInfo[idx] ? styles.collapsed : ""
+                    )}>
+                      {
+                        item.type === "BingBrowser.search" && <div className={styles.thought}>
+                          <ReactMarkdown rehypePlugins={[rehypeRaw]}>{progress1}</ReactMarkdown>
+                        </div>
+                      }
+                      {
+                        item.type === "BingBrowser.search" && query.length > 0 && <div className={styles.query}>
+                          <div className={styles.subTitle}><IconFont type="icon-SearchOutlined" />搜索关键词</div>
+                          {
+                            query.map((item, index) => (<div key={`query-item-${item}`} className={classNames(styles.queryItem, styles.fadeIn)}>
+                              {item}
+                            </div>))
+                          }
+                        </div>
+                      }
+                      {
+                        currentStep === idx && searchList.length > 0 && <div className={styles.searchList}>
+                          {item.type === "BingBrowser.search" && <div className={styles.subTitle}><IconFont type="icon-DocOutlined" />信息来源</div>}
+                          {
+                            item.type === "BingBrowser.select" && <div className={styles.thought}>
+                              <ReactMarkdown rehypePlugins={[rehypeRaw]}>{progress2}</ReactMarkdown>
+                            </div>
+                          }
+                          <div className={styles.scrollCon} style={(searchList.length > 5 && currentStep === 0) ? { height: '300px' } : {}}>
+
+                            <div className={styles.inner} style={(searchList.length > 5 && currentStep === 0) ? { position: 'absolute', bottom: 0, left: 0 } : {}}>
+
+                              {
+                                searchList.map((item: any, num: number) => (
+                                  <div className={classNames(
+                                    styles.searchItem,
+                                    item.highLight ? styles.highLight : ""
+                                  )} key={`search-item-${item.url}-${idx}`}>
+                                    <p className={styles.summ}>{item.id}. {item?.title}</p>
+                                    <p className={styles.url}>{item?.url}</p>
+                                  </div>
+                                ))
+                              }
+                            </div>
+                          </div>
+                        </div>
+                      }
+                    </div>
+                  </div>
+                ))
+              }
+            </> : <></>
+          }
+        </>
+      }
+      {
+        conclusion && <div className={styles.steps}>
+          <div className={styles.title}>
+            <i></i>信息整合
+          </div>
+          <div className={styles.conclusion}>
+            <ReactMarkdown rehypePlugins={[rehypeRaw]}>{conclusion}</ReactMarkdown>
+          </div>
+        </div>
+      }
+      {isWaiting && question && <div className={styles.loading99}></div>}
+    </div>}
+    {
+      !showRight && <div className={styles.showRight} onClick={toggleRight}>
+        <img src={ShowRightIcon} />
+      </div>
+    }
+
+  </div>
+};
+
+export default RenderTest;

frontend/React/src/pages/render/mindMapItem.tsx

@@ -0,0 +1,39 @@
+import styles from './index.module.less';
+import classNames from 'classnames';
+
+// 递归组件用于渲染mindMap中的节点
+const MindMapItem = ({ item, isEnd }: any) => {
+  // 递归渲染子节点
+  const renderChildren = () => {
+    if (item.children && item.children.length > 0) {
+      return (
+        <ul className={item.children.length === 1 ? styles.onlyone : ''}>
+          {item.children.map((child: any) => (
+            <MindMapItem key={child.name} item={child} isEnd={isEnd} />
+          ))}
+        </ul>
+      );
+    }
+    return null;
+  };
+
+  return (
+    <li>
+      <article className={
+        classNames(
+          item.state === 1 ? styles.loading : item.state === 2 ? styles.disabled : item.state === 3 ? styles.finished : "",
+          item.id === 0 ? styles.init : ''
+        )}>
+        <span>{item.name}</span>
+        {item.state === 1 && <div className={styles.looping}></div>}
+        {item.id !== 0 && <div className={styles.finishDot}></div>}
+      </article>
+      {item.children.length > 0 && renderChildren()}
+      {
+        isEnd && item.children?.length === 0 && <div className={classNames(styles.endLine, "endline")}></div>
+      }
+    </li>
+  );
+};
+
+export default MindMapItem;

frontend/React/src/routes/routes.tsx

@@ -0,0 +1,38 @@
+import RenderTest from "@/pages/render";
+
+import { ReactElement } from "react";
+import { Navigate, useRoutes } from "react-router-dom";
+
+interface RouteItem {
+  path: string;
+  needLogin?: boolean;
+  element: ReactElement;
+}
+
+const routes: RouteItem[] = [
+  {
+    path: "/",
+    needLogin: false,
+    element: <RenderTest />,
+  },
+  {
+    path: "*",
+    element: <Navigate to="/" />,
+  },
+];
+
+const WrapperRoutes = () => {
+  return useRoutes(
+    routes.map((item: RouteItem) => {
+      if (item.needLogin) {
+        return {
+          ...item,
+          element: <></>,
+        };
+      }
+      return item;
+    }),
+  );
+};
+
+export default WrapperRoutes;

frontend/React/src/utils/tools.ts

@@ -0,0 +1,24 @@
+export const getQueryString = (search: string, name: string) => {
+  if (!search) return "";
+  const reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)");
+  const result = search.substring(1).match(reg);
+  if (result != null) return result[2];
+  return "";
+};
+
+export const isInWhiteList = (url: string = "", list: string[] = []) => {
+  const baseUrl = url.split("?")[0];
+  for (let whiteApi of list) {
+    if (baseUrl.endsWith(whiteApi)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+export const replaceStr = (str: string) => {
+  return str.replace(/\[\[(\d+)\]\]/g, (match: any, number: any) => {
+    // 创建一个带有class为'fnn2'的span元素，并将数字作为文本内容
+    return `<i class='f'>${number}</i>`;
+  });
+};

frontend/React/src/vite-env.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+  readonly VITE_SSO_URL: string;
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv;
+}

frontend/React/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES5",
+    "useDefineForClassFields": true,
+    "lib": ["DOM", "DOM.Iterable", "ESNext"],
+    "allowJs": false,
+    "skipLibCheck": true,
+    "esModuleInterop": false,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "baseUrl": "./",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src"]
+}

frontend/React/vite.config.ts

@@ -0,0 +1,62 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import path from "path";
+import legacy from "@vitejs/plugin-legacy";
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [
+    react({
+      babel: {
+        plugins: [
+          "@babel/plugin-proposal-optional-chaining", // 兼容老版本浏览器的语法解译
+        ],
+      },
+    }),
+    legacy({
+      targets: ["defaults", "ie >= 11", "chrome >= 52"], //需要兼容的目标列表，可以设置多个
+      additionalLegacyPolyfills: ["regenerator-runtime/runtime"],
+      renderLegacyChunks: true,
+      polyfills: [
+        "es.symbol",
+        "es.array.filter",
+        "es.promise",
+        "es.promise.finally",
+        "es/map",
+        "es/set",
+        "es.array.for-each",
+        "es.object.define-properties",
+        "es.object.define-property",
+        "es.object.get-own-property-descriptor",
+        "es.object.get-own-property-descriptors",
+        "es.object.keys",
+        "es.object.to-string",
+        "web.dom-collections.for-each",
+        "esnext.global-this",
+        "esnext.string.match-all",
+      ],
+    }),
+  ],
+  build: {
+    target: "es5",
+  },
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "src"),
+    },
+  },
+  css: {
+    modules: {
+      localsConvention: "camelCase",
+    },
+  },
+  server: {
+    port: 8080,
+    proxy: {
+      // "/solve": {
+      //   target: "...",
+      //   changeOrigin: true,
+      // },
+    },
+  },
+});

frontend/mindsearch_gradio.py

@@ -0,0 +1,142 @@
+import json
+
+import gradio as gr
+import requests
+from lagent.schema import AgentStatusCode
+
+PLANNER_HISTORY = []
+SEARCHER_HISTORY = []
+
+
+def rst_mem(history_planner: list, history_searcher: list):
+    '''
+    Reset the chatbot memory.
+    '''
+    history_planner = []
+    history_searcher = []
+    if PLANNER_HISTORY:
+        PLANNER_HISTORY.clear()
+    return history_planner, history_searcher
+
+
+def format_response(gr_history, agent_return):
+    if agent_return['state'] in [
+            AgentStatusCode.STREAM_ING, AgentStatusCode.ANSWER_ING
+    ]:
+        gr_history[-1][1] = agent_return['response']
+    elif agent_return['state'] == AgentStatusCode.PLUGIN_START:
+        thought = gr_history[-1][1].split('```')[0]
+        if agent_return['response'].startswith('```'):
+            gr_history[-1][1] = thought + '\n' + agent_return['response']
+    elif agent_return['state'] == AgentStatusCode.PLUGIN_END:
+        thought = gr_history[-1][1].split('```')[0]
+        if isinstance(agent_return['response'], dict):
+            gr_history[-1][
+                1] = thought + '\n' + f'```json\n{json.dumps(agent_return["response"], ensure_ascii=False, indent=4)}\n```'  # noqa: E501
+    elif agent_return['state'] == AgentStatusCode.PLUGIN_RETURN:
+        assert agent_return['inner_steps'][-1]['role'] == 'environment'
+        item = agent_return['inner_steps'][-1]
+        gr_history.append([
+            None,
+            f"```json\n{json.dumps(item['content'], ensure_ascii=False, indent=4)}\n```"
+        ])
+        gr_history.append([None, ''])
+    return
+
+
+def predict(history_planner, history_searcher):
+
+    def streaming(raw_response):
+        for chunk in raw_response.iter_lines(chunk_size=8192,
+                                             decode_unicode=False,
+                                             delimiter=b'\n'):
+            if chunk:
+                decoded = chunk.decode('utf-8')
+                if decoded == '\r':
+                    continue
+                if decoded[:6] == 'data: ':
+                    decoded = decoded[6:]
+                elif decoded.startswith(': ping - '):
+                    continue
+                response = json.loads(decoded)
+                yield (response['response'], response['current_node'])
+
+    global PLANNER_HISTORY
+    PLANNER_HISTORY.append(dict(role='user', content=history_planner[-1][0]))
+    new_search_turn = True
+
+    url = 'http://localhost:8002/solve'
+    headers = {'Content-Type': 'application/json'}
+    data = {'inputs': PLANNER_HISTORY}
+    raw_response = requests.post(url,
+                                 headers=headers,
+                                 data=json.dumps(data),
+                                 timeout=20,
+                                 stream=True)
+
+    for resp in streaming(raw_response):
+        agent_return, node_name = resp
+        if node_name:
+            if node_name in ['root', 'response']:
+                continue
+            agent_return = agent_return['nodes'][node_name]['detail']
+            if new_search_turn:
+                history_searcher.append([agent_return['content'], ''])
+                new_search_turn = False
+            format_response(history_searcher, agent_return)
+            if agent_return['state'] == AgentStatusCode.END:
+                new_search_turn = True
+            yield history_planner, history_searcher
+        else:
+            new_search_turn = True
+            format_response(history_planner, agent_return)
+            if agent_return['state'] == AgentStatusCode.END:
+                PLANNER_HISTORY = agent_return['inner_steps']
+            yield history_planner, history_searcher
+    return history_planner, history_searcher
+
+
+with gr.Blocks() as demo:
+    gr.HTML("""<h1 align="center">WebAgent Gradio Simple Demo</h1>""")
+    with gr.Row():
+        with gr.Column(scale=10):
+            with gr.Row():
+                with gr.Column():
+                    planner = gr.Chatbot(label='planner',
+                                         height=700,
+                                         show_label=True,
+                                         show_copy_button=True,
+                                         bubble_full_width=False,
+                                         render_markdown=True)
+                with gr.Column():
+                    searcher = gr.Chatbot(label='searcher',
+                                          height=700,
+                                          show_label=True,
+                                          show_copy_button=True,
+                                          bubble_full_width=False,
+                                          render_markdown=True)
+            with gr.Row():
+                user_input = gr.Textbox(show_label=False,
+                                        placeholder='inputs...',
+                                        lines=5,
+                                        container=False)
+            with gr.Row():
+                with gr.Column(scale=2):
+                    submitBtn = gr.Button('Submit')
+                with gr.Column(scale=1, min_width=20):
+                    emptyBtn = gr.Button('Clear History')
+
+    def user(query, history):
+        return '', history + [[query, '']]
+
+    submitBtn.click(user, [user_input, planner], [user_input, planner],
+                    queue=False).then(predict, [planner, searcher],
+                                      [planner, searcher])
+    emptyBtn.click(rst_mem, [planner, searcher], [planner, searcher],
+                   queue=False)
+
+demo.queue()
+demo.launch(server_name='127.0.0.1',
+            server_port=7882,
+            inbrowser=True,
+            share=True)

frontend/mindsearch_streamlit.py

@@ -0,0 +1,319 @@
+import json
+import tempfile
+
+import requests
+import streamlit as st
+from lagent.schema import AgentStatusCode
+from pyvis.network import Network
+
+
+# Function to create the network graph
+def create_network_graph(nodes, adjacency_list):
+    net = Network(height='500px',
+                  width='60%',
+                  bgcolor='white',
+                  font_color='black')
+    for node_id, node_data in nodes.items():
+        if node_id in ['root', 'response']:
+            title = node_data.get('content', node_id)
+        else:
+            title = node_data['detail']['content']
+        net.add_node(node_id,
+                     label=node_id,
+                     title=title,
+                     color='#FF5733',
+                     size=25)
+    for node_id, neighbors in adjacency_list.items():
+        for neighbor in neighbors:
+            if neighbor['name'] in nodes:
+                net.add_edge(node_id, neighbor['name'])
+    net.show_buttons(filter_=['physics'])
+    return net
+
+
+# Function to draw the graph and return the HTML file path
+def draw_graph(net):
+    path = tempfile.mktemp(suffix='.html')
+    net.save_graph(path)
+    return path
+
+
+def streaming(raw_response):
+    for chunk in raw_response.iter_lines(chunk_size=8192,
+                                         decode_unicode=False,
+                                         delimiter=b'\n'):
+        if chunk:
+            decoded = chunk.decode('utf-8')
+            if decoded == '\r':
+                continue
+            if decoded[:6] == 'data: ':
+                decoded = decoded[6:]
+            elif decoded.startswith(': ping - '):
+                continue
+            response = json.loads(decoded)
+            yield (response['response'], response['current_node'])
+
+
+# Initialize Streamlit session state
+if 'queries' not in st.session_state:
+    st.session_state['queries'] = []
+    st.session_state['responses'] = []
+    st.session_state['graphs_html'] = []
+    st.session_state['nodes_list'] = []
+    st.session_state['adjacency_list_list'] = []
+    st.session_state['history'] = []
+    st.session_state['already_used_keys'] = list()
+
+# Set up page layout
+st.set_page_config(layout='wide')
+st.title('MindSearch-思索')
+
+
+# Function to update chat
+def update_chat(query):
+    with st.chat_message('user'):
+        st.write(query)
+    if query not in st.session_state['queries']:
+        # Mock data to simulate backend response
+        # response, history, nodes, adjacency_list
+        st.session_state['queries'].append(query)
+        st.session_state['responses'].append([])
+        history = None
+        # 暂不支持多轮
+        message = [dict(role='user', content=query)]
+
+        url = 'http://localhost:8002/solve'
+        headers = {'Content-Type': 'application/json'}
+        data = {'inputs': message}
+        raw_response = requests.post(url,
+                                     headers=headers,
+                                     data=json.dumps(data),
+                                     timeout=20,
+                                     stream=True)
+
+        for resp in streaming(raw_response):
+            agent_return, node_name = resp
+            if node_name and node_name in ['root', 'response']:
+                continue
+            nodes = agent_return['nodes']
+            adjacency_list = agent_return['adj']
+            response = agent_return['response']
+            history = agent_return['inner_steps']
+            if nodes:
+                net = create_network_graph(nodes, adjacency_list)
+                graph_html_path = draw_graph(net)
+                with open(graph_html_path, encoding='utf-8') as f:
+                    graph_html = f.read()
+            else:
+                graph_html = None
+            if 'graph_placeholder' not in st.session_state:
+                st.session_state['graph_placeholder'] = st.empty()
+            if 'expander_placeholder' not in st.session_state:
+                st.session_state['expander_placeholder'] = st.empty()
+            if graph_html:
+                with st.session_state['expander_placeholder'].expander(
+                        'Show Graph', expanded=False):
+                    st.session_state['graph_placeholder']._html(graph_html,
+                                                                height=500)
+            if 'container_placeholder' not in st.session_state:
+                st.session_state['container_placeholder'] = st.empty()
+            with st.session_state['container_placeholder'].container():
+                if 'columns_placeholder' not in st.session_state:
+                    st.session_state['columns_placeholder'] = st.empty()
+                col1, col2 = st.session_state['columns_placeholder'].columns(
+                    [2, 1])
+                with col1:
+                    if 'planner_placeholder' not in st.session_state:
+                        st.session_state['planner_placeholder'] = st.empty()
+                    if 'session_info_temp' not in st.session_state:
+                        st.session_state['session_info_temp'] = ''
+                    if not node_name:
+                        if agent_return['state'] in [
+                                AgentStatusCode.STREAM_ING,
+                                AgentStatusCode.ANSWER_ING
+                        ]:
+                            st.session_state['session_info_temp'] = response
+                        elif agent_return[
+                                'state'] == AgentStatusCode.PLUGIN_START:
+                            thought = st.session_state[
+                                'session_info_temp'].split('```')[0]
+                            if agent_return['response'].startswith('```'):
+                                st.session_state[
+                                    'session_info_temp'] = thought + '\n' + response
+                        elif agent_return[
+                                'state'] == AgentStatusCode.PLUGIN_RETURN:
+                            assert agent_return['inner_steps'][-1][
+                                'role'] == 'environment'
+                            st.session_state[
+                                'session_info_temp'] += '\n' + agent_return[
+                                    'inner_steps'][-1]['content']
+                        st.session_state['planner_placeholder'].markdown(
+                            st.session_state['session_info_temp'])
+                        if agent_return[
+                                'state'] == AgentStatusCode.PLUGIN_RETURN:
+                            st.session_state['responses'][-1].append(
+                                st.session_state['session_info_temp'])
+                            st.session_state['session_info_temp'] = ''
+                    else:
+                        st.session_state['planner_placeholder'].markdown(
+                            st.session_state['responses'][-1][-1] if
+                            not st.session_state['session_info_temp'] else st.
+                            session_state['session_info_temp'])
+                with col2:
+                    if 'selectbox_placeholder' not in st.session_state:
+                        st.session_state['selectbox_placeholder'] = st.empty()
+                    if 'searcher_placeholder' not in st.session_state:
+                        st.session_state['searcher_placeholder'] = st.empty()
+                    # st.session_state['searcher_placeholder'].markdown('')
+                    if node_name:
+                        selected_node_key = f"selected_node_{len(st.session_state['queries'])}_{node_name}"
+                        if selected_node_key not in st.session_state:
+                            st.session_state[selected_node_key] = node_name
+                        if selected_node_key not in st.session_state[
+                                'already_used_keys']:
+                            selected_node = st.session_state[
+                                'selectbox_placeholder'].selectbox(
+                                    'Select a node:',
+                                    list(nodes.keys()),
+                                    key=f'key_{selected_node_key}',
+                                    index=list(nodes.keys()).index(node_name))
+                            st.session_state['already_used_keys'].append(
+                                selected_node_key)
+                        else:
+                            selected_node = node_name
+                        st.session_state[selected_node_key] = selected_node
+                        if selected_node in nodes:
+                            node = nodes[selected_node]
+                            agent_return = node['detail']
+                            node_info_key = f'{selected_node}_info'
+                            if 'node_info_temp' not in st.session_state:
+                                st.session_state[
+                                    'node_info_temp'] = f'### {agent_return["content"]}'
+                            if node_info_key not in st.session_state:
+                                st.session_state[node_info_key] = []
+                            if agent_return['state'] in [
+                                    AgentStatusCode.STREAM_ING,
+                                    AgentStatusCode.ANSWER_ING
+                            ]:
+                                st.session_state[
+                                    'node_info_temp'] = agent_return[
+                                        'response']
+                            elif agent_return[
+                                    'state'] == AgentStatusCode.PLUGIN_START:
+                                thought = st.session_state[
+                                    'node_info_temp'].split('```')[0]
+                                if agent_return['response'].startswith('```'):
+                                    st.session_state[
+                                        'node_info_temp'] = thought + '\n' + agent_return[
+                                            'response']
+                            elif agent_return[
+                                    'state'] == AgentStatusCode.PLUGIN_END:
+                                thought = st.session_state[
+                                    'node_info_temp'].split('```')[0]
+                                if isinstance(agent_return['response'], dict):
+                                    st.session_state[
+                                        'node_info_temp'] = thought + '\n' + f'```json\n{json.dumps(agent_return["response"], ensure_ascii=False, indent=4)}\n```'  # noqa: E501
+                            elif agent_return[
+                                    'state'] == AgentStatusCode.PLUGIN_RETURN:
+                                assert agent_return['inner_steps'][-1][
+                                    'role'] == 'environment'
+                                st.session_state[node_info_key].append(
+                                    ('thought',
+                                     st.session_state['node_info_temp']))
+                                st.session_state[node_info_key].append(
+                                    ('observation',
+                                     agent_return['inner_steps'][-1]['content']
+                                     ))
+                            st.session_state['searcher_placeholder'].markdown(
+                                st.session_state['node_info_temp'])
+                            if agent_return['state'] == AgentStatusCode.END:
+                                st.session_state[node_info_key].append(
+                                    ('answer',
+                                     st.session_state['node_info_temp']))
+                                st.session_state['node_info_temp'] = ''
+        if st.session_state['session_info_temp']:
+            st.session_state['responses'][-1].append(
+                st.session_state['session_info_temp'])
+            st.session_state['session_info_temp'] = ''
+        # st.session_state['responses'][-1] = '\n'.join(st.session_state['responses'][-1])
+        st.session_state['graphs_html'].append(graph_html)
+        st.session_state['nodes_list'].append(nodes)
+        st.session_state['adjacency_list_list'].append(adjacency_list)
+        st.session_state['history'] = history
+
+
+def display_chat_history():
+    for i, query in enumerate(st.session_state['queries'][-1:]):
+        # with st.chat_message('assistant'):
+        if st.session_state['graphs_html'][i]:
+            with st.session_state['expander_placeholder'].expander(
+                    'Show Graph', expanded=False):
+                st.session_state['graph_placeholder']._html(
+                    st.session_state['graphs_html'][i], height=500)
+            with st.session_state['container_placeholder'].container():
+                col1, col2 = st.session_state['columns_placeholder'].columns(
+                    [2, 1])
+                with col1:
+                    st.session_state['planner_placeholder'].markdown(
+                        st.session_state['responses'][-1][-1])
+                with col2:
+                    selected_node_key = st.session_state['already_used_keys'][
+                        -1]
+                    st.session_state['selectbox_placeholder'] = st.empty()
+                    selected_node = st.session_state[
+                        'selectbox_placeholder'].selectbox(
+                            'Select a node:',
+                            list(st.session_state['nodes_list'][i].keys()),
+                            key=f'replay_key_{i}',
+                            index=list(st.session_state['nodes_list'][i].keys(
+                            )).index(st.session_state[selected_node_key]))
+                    st.session_state[selected_node_key] = selected_node
+                    if selected_node not in [
+                            'root', 'response'
+                    ] and selected_node in st.session_state['nodes_list'][i]:
+                        node_info_key = f'{selected_node}_info'
+                        for item in st.session_state[node_info_key]:
+                            if item[0] in ['thought', 'answer']:
+                                st.session_state[
+                                    'searcher_placeholder'] = st.empty()
+                                st.session_state[
+                                    'searcher_placeholder'].markdown(item[1])
+                            elif item[0] == 'observation':
+                                st.session_state[
+                                    'observation_expander'] = st.empty()
+                                with st.session_state[
+                                        'observation_expander'].expander(
+                                            'Results'):
+                                    st.write(item[1])
+                        # st.session_state['searcher_placeholder'].markdown(st.session_state[node_info_key])
+
+
+def clean_history():
+    st.session_state['queries'] = []
+    st.session_state['responses'] = []
+    st.session_state['graphs_html'] = []
+    st.session_state['nodes_list'] = []
+    st.session_state['adjacency_list_list'] = []
+    st.session_state['history'] = []
+    st.session_state['already_used_keys'] = list()
+    for k in st.session_state:
+        if k.endswith('placeholder') or k.endswith('_info'):
+            del st.session_state[k]
+
+
+# Main function to run the Streamlit app
+def main():
+    st.sidebar.title('Model Control')
+    col1, col2 = st.columns([4, 1])
+    with col1:
+        user_input = st.chat_input('Enter your query:')
+    with col2:
+        if st.button('Clear History'):
+            clean_history()
+    if user_input:
+        update_chat(user_input)
+    display_chat_history()
+
+
+if __name__ == '__main__':
+    main()

mindsearch/agent/__init__.py

@@ -0,0 +1,54 @@
+import os
+from datetime import datetime
+
+from lagent.actions import ActionExecutor, BingBrowser
+
+import mindsearch.agent.models as llm_factory
+from mindsearch.agent.mindsearch_agent import (MindSearchAgent,
+                                               MindSearchProtocol)
+from mindsearch.agent.mindsearch_prompt import (
+    FINAL_RESPONSE_CN, FINAL_RESPONSE_EN, GRAPH_PROMPT_CN, GRAPH_PROMPT_EN,
+    searcher_context_template_cn, searcher_context_template_en,
+    searcher_input_template_cn, searcher_input_template_en,
+    searcher_system_prompt_cn, searcher_system_prompt_en)
+
+LLM = {}
+
+
+def init_agent(lang='cn', model_format='internlm_server'):
+    llm = LLM.get(model_format, None)
+    if llm is None:
+        llm_cfg = getattr(llm_factory, model_format)
+        if llm_cfg is None:
+            raise NotImplementedError
+        llm_cfg = llm_cfg.copy()
+        llm = llm_cfg.pop('type')(**llm_cfg)
+        LLM[model_format] = llm
+
+    agent = MindSearchAgent(
+        llm=llm,
+        protocol=MindSearchProtocol(meta_prompt=datetime.now().strftime(
+            'The current date is %Y-%m-%d.'),
+                                    interpreter_prompt=GRAPH_PROMPT_CN
+                                    if lang == 'cn' else GRAPH_PROMPT_EN,
+                                    response_prompt=FINAL_RESPONSE_CN
+                                    if lang == 'cn' else FINAL_RESPONSE_EN),
+        searcher_cfg=dict(
+            llm=llm,
+            plugin_executor=ActionExecutor(
+                BingBrowser(searcher_type='DuckDuckGoSearch',
+                            topk=6,
+                            api_key=os.environ.get('BING_API_KEY',
+                                                   'YOUR BING API'))),
+            protocol=MindSearchProtocol(
+                meta_prompt=datetime.now().strftime(
+                    'The current date is %Y-%m-%d.'),
+                plugin_prompt=searcher_system_prompt_cn
+                if lang == 'cn' else searcher_system_prompt_en,
+            ),
+            template=dict(input=searcher_input_template_cn
+                          if lang == 'cn' else searcher_input_template_en,
+                          context=searcher_context_template_cn
+                          if lang == 'cn' else searcher_context_template_en)),
+        max_turn=10)
+    return agent

mindsearch/agent/mindsearch_agent.py

@@ -0,0 +1,408 @@
+import json
+import logging
+import queue
+import random
+import re
+import threading
+import uuid
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from copy import deepcopy
+from dataclasses import asdict
+from typing import Dict, List, Optional
+
+from lagent.actions import ActionExecutor
+from lagent.agents import BaseAgent, Internlm2Agent
+from lagent.agents.internlm2_agent import Internlm2Protocol
+from lagent.schema import AgentReturn, AgentStatusCode, ModelStatusCode
+from termcolor import colored
+
+# 初始化日志记录
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class SearcherAgent(Internlm2Agent):
+
+    def __init__(self, template='{query}', **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.template = template
+
+    def stream_chat(self,
+                    question: str,
+                    root_question: str = None,
+                    parent_response: List[dict] = None,
+                    **kwargs) -> AgentReturn:
+        message = self.template['input'].format(question=question,
+                                                topic=root_question)
+        if parent_response:
+            if 'context' in self.template:
+                parent_response = [
+                    self.template['context'].format(**item)
+                    for item in parent_response
+                ]
+                message = '\n'.join(parent_response + [message])
+        print(colored(f'current query: {message}', 'green'))
+        for agent_return in super().stream_chat(message,
+                                                session_id=random.randint(
+                                                    0, 999999),
+                                                **kwargs):
+            agent_return.type = 'searcher'
+            agent_return.content = question
+            yield deepcopy(agent_return)
+
+
+class MindSearchProtocol(Internlm2Protocol):
+
+    def __init__(
+        self,
+        meta_prompt: str = None,
+        interpreter_prompt: str = None,
+        plugin_prompt: str = None,
+        few_shot: Optional[List] = None,
+        response_prompt: str = None,
+        language: Dict = dict(
+            begin='',
+            end='',
+            belong='assistant',
+        ),
+        tool: Dict = dict(
+            begin='{start_token}{name}\n',
+            start_token='<|action_start|>',
+            name_map=dict(plugin='<|plugin|>', interpreter='<|interpreter|>'),
+            belong='assistant',
+            end='<|action_end|>\n',
+        ),
+        execute: Dict = dict(role='execute',
+                             begin='',
+                             end='',
+                             fallback_role='environment'),
+    ) -> None:
+        self.response_prompt = response_prompt
+        super().__init__(meta_prompt=meta_prompt,
+                         interpreter_prompt=interpreter_prompt,
+                         plugin_prompt=plugin_prompt,
+                         few_shot=few_shot,
+                         language=language,
+                         tool=tool,
+                         execute=execute)
+
+    def format(self,
+               inner_step: List[Dict],
+               plugin_executor: ActionExecutor = None,
+               **kwargs) -> list:
+        formatted = []
+        if self.meta_prompt:
+            formatted.append(dict(role='system', content=self.meta_prompt))
+        if self.plugin_prompt:
+            plugin_prompt = self.plugin_prompt.format(tool_info=json.dumps(
+                plugin_executor.get_actions_info(), ensure_ascii=False))
+            formatted.append(
+                dict(role='system', content=plugin_prompt, name='plugin'))
+        if self.interpreter_prompt:
+            formatted.append(
+                dict(role='system',
+                     content=self.interpreter_prompt,
+                     name='interpreter'))
+        if self.few_shot:
+            for few_shot in self.few_shot:
+                formatted += self.format_sub_role(few_shot)
+        formatted += self.format_sub_role(inner_step)
+        return formatted
+
+
+class WebSearchGraph:
+    end_signal = 'end'
+    searcher_cfg = dict()
+
+    def __init__(self):
+        self.nodes = {}
+        self.adjacency_list = defaultdict(list)
+        self.executor = ThreadPoolExecutor(max_workers=10)
+        self.future_to_query = dict()
+        self.searcher_resp_queue = queue.Queue()
+
+    def add_root_node(self, node_content, node_name='root'):
+        self.nodes[node_name] = dict(content=node_content, type='root')
+        self.adjacency_list[node_name] = []
+        self.searcher_resp_queue.put((node_name, self.nodes[node_name], []))
+
+    def add_node(self, node_name, node_content):
+        self.nodes[node_name] = dict(content=node_content, type='searcher')
+        self.adjacency_list[node_name] = []
+
+        def model_stream_thread():
+            agent = SearcherAgent(**self.searcher_cfg)
+            try:
+                parent_nodes = []
+                for start_node, adj in self.adjacency_list.items():
+                    for neighbor in adj:
+                        if node_name == neighbor[
+                                'name'] and start_node in self.nodes and 'response' in self.nodes[
+                                    start_node]:
+                            parent_nodes.append(self.nodes[start_node])
+                parent_response = [
+                    dict(question=node['content'], answer=node['response'])
+                    for node in parent_nodes
+                ]
+                for answer in agent.stream_chat(
+                        node_content,
+                        self.nodes['root']['content'],
+                        parent_response=parent_response):
+                    self.searcher_resp_queue.put(
+                        deepcopy((node_name,
+                                  dict(response=answer.response,
+                                       detail=answer), [])))
+                self.nodes[node_name]['response'] = answer.response
+                self.nodes[node_name]['detail'] = answer
+            except Exception as e:
+                logger.exception(f'Error in model_stream_thread: {e}')
+
+        self.future_to_query[self.executor.submit(
+            model_stream_thread)] = f'{node_name}-{node_content}'
+
+    def add_response_node(self, node_name='response'):
+        self.nodes[node_name] = dict(type='end')
+        self.searcher_resp_queue.put((node_name, self.nodes[node_name], []))
+
+    def add_edge(self, start_node, end_node):
+        self.adjacency_list[start_node].append(
+            dict(id=str(uuid.uuid4()), name=end_node, state=2))
+        self.searcher_resp_queue.put((start_node, self.nodes[start_node],
+                                      self.adjacency_list[start_node]))
+
+    def reset(self):
+        self.nodes = {}
+        self.adjacency_list = defaultdict(list)
+
+    def node(self, node_name):
+        return self.nodes[node_name].copy()
+
+
+class MindSearchAgent(BaseAgent):
+
+    def __init__(self,
+                 llm,
+                 searcher_cfg,
+                 protocol=MindSearchProtocol(),
+                 max_turn=10):
+        self.local_dict = {}
+        self.ptr = 0
+        self.llm = llm
+        self.max_turn = max_turn
+        WebSearchGraph.searcher_cfg = searcher_cfg
+        super().__init__(llm=llm, action_executor=None, protocol=protocol)
+
+    def stream_chat(self, message, **kwargs):
+        if isinstance(message, str):
+            message = [{'role': 'user', 'content': message}]
+        elif isinstance(message, dict):
+            message = [message]
+        self.local_dict.clear()
+        self.ptr = 0
+        inner_history = message[:]
+        agent_return = AgentReturn()
+        agent_return.type = 'planner'
+        agent_return.nodes = {}
+        agent_return.adjacency_list = {}
+        agent_return.inner_steps = deepcopy(inner_history)
+        for _ in range(self.max_turn):
+            prompt = self._protocol.format(inner_step=inner_history)
+            for model_state, response, _ in self.llm.stream_chat(
+                    prompt, session_id=random.randint(0, 999999), **kwargs):
+                if model_state.value < 0:
+                    agent_return.state = getattr(AgentStatusCode,
+                                                 model_state.name)
+                    yield deepcopy(agent_return)
+                    return
+                response = response.replace('<|plugin|>', '<|interpreter|>')
+                _, language, action = self._protocol.parse(response)
+                if not language and not action:
+                    continue
+                code = action['parameters']['command'] if action else ''
+                agent_return.state = self._determine_agent_state(
+                    model_state, code, agent_return)
+                agent_return.response = language if not code else code
+
+                # if agent_return.state == AgentStatusCode.STREAM_ING:
+                yield deepcopy(agent_return)
+
+            inner_history.append({'role': 'language', 'content': language})
+            print(colored(response, 'blue'))
+
+            if code:
+                yield from self._process_code(
+                    agent_return, inner_history, code,
+                    kwargs.get('as_dict', False),
+                    kwargs.get('return_early', False))
+            else:
+                agent_return.state = AgentStatusCode.END
+                yield deepcopy(agent_return)
+                return
+
+        agent_return.state = AgentStatusCode.END
+        yield deepcopy(agent_return)
+
+    def _determine_agent_state(self, model_state, code, agent_return):
+        if code:
+            return (AgentStatusCode.PLUGIN_START if model_state
+                    == ModelStatusCode.END else AgentStatusCode.PLUGIN_START)
+        return (AgentStatusCode.ANSWER_ING
+                if agent_return.nodes and 'response' in agent_return.nodes else
+                AgentStatusCode.STREAM_ING)
+
+    def _process_code(self,
+                      agent_return,
+                      inner_history,
+                      code,
+                      as_dict=False,
+                      return_early=False):
+        for node_name, node, adj in self.execute_code(
+                code, return_early=return_early):
+            if as_dict and 'detail' in node:
+                node['detail'] = asdict(node['detail'])
+            if not adj:
+                agent_return.nodes[node_name] = node
+            else:
+                agent_return.adjacency_list[node_name] = adj
+            # state  1进行中，2未开始，3已结束
+            for start_node, neighbors in agent_return.adjacency_list.items():
+                for neighbor in neighbors:
+                    if neighbor['name'] not in agent_return.nodes:
+                        state = 2
+                    elif 'detail' not in agent_return.nodes[neighbor['name']]:
+                        state = 2
+                    elif agent_return.nodes[neighbor['name']][
+                            'detail'].state == AgentStatusCode.END:
+                        state = 3
+                    else:
+                        state = 1
+                    neighbor['state'] = state
+            if not adj:
+                yield deepcopy((agent_return, node_name))
+        reference, references_url = self._generate_reference(
+            agent_return, code, as_dict)
+        inner_history.append({
+            'role': 'tool',
+            'content': code,
+            'name': 'plugin'
+        })
+        inner_history.append({
+            'role': 'environment',
+            'content': reference,
+            'name': 'plugin'
+        })
+        agent_return.inner_steps = deepcopy(inner_history)
+        agent_return.state = AgentStatusCode.PLUGIN_RETURN
+        agent_return.references.update(references_url)
+        yield deepcopy(agent_return)
+
+    def _generate_reference(self, agent_return, code, as_dict):
+        node_list = [
+            node.strip().strip('\"') for node in re.findall(
+                r'graph\.node\("((?:[^"\\]|\\.)*?)"\)', code)
+        ]
+        if 'add_response_node' in code:
+            return self._protocol.response_prompt, dict()
+        references = []
+        references_url = dict()
+        for node_name in node_list:
+            if as_dict:
+                ref_results = agent_return.nodes[node_name]['detail'][
+                    'actions'][0]['result'][0]['content']
+            else:
+                ref_results = agent_return.nodes[node_name]['detail'].actions[
+                    0].result[0]['content']
+            ref_results = json.loads(ref_results)
+            ref2url = {idx: item['url'] for idx, item in ref_results.items()}
+            ref = f"## {node_name}\n\n{agent_return.nodes[node_name]['response']}\n"
+            updated_ref = re.sub(
+                r'\[\[(\d+)\]\]',
+                lambda match: f'[[{int(match.group(1)) + self.ptr}]]', ref)
+            numbers = [int(n) for n in re.findall(r'\[\[(\d+)\]\]', ref)]
+            if numbers:
+                assert all(str(elem) in ref2url for elem in numbers)
+                references_url.update({
+                    str(idx + self.ptr): ref2url[str(idx)]
+                    for idx in set(numbers)
+                })
+                self.ptr += max(numbers) + 1
+            references.append(updated_ref)
+        return '\n'.join(references), references_url
+
+    def execute_code(self, command: str, return_early=False):
+
+        def extract_code(text: str) -> str:
+            text = re.sub(r'from ([\w.]+) import WebSearchGraph', '', text)
+            triple_match = re.search(r'```[^\n]*\n(.+?)```', text, re.DOTALL)
+            single_match = re.search(r'`([^`]*)`', text, re.DOTALL)
+            if triple_match:
+                return triple_match.group(1)
+            elif single_match:
+                return single_match.group(1)
+            return text
+
+        def run_command(cmd):
+            try:
+                exec(cmd, globals(), self.local_dict)
+                plan_graph = self.local_dict.get('graph')
+                assert plan_graph is not None
+                for future in as_completed(plan_graph.future_to_query):
+                    future.result()
+                plan_graph.future_to_query.clear()
+                plan_graph.searcher_resp_queue.put(plan_graph.end_signal)
+            except Exception as e:
+                logger.exception(f'Error executing code: {e}')
+
+        command = extract_code(command)
+        producer_thread = threading.Thread(target=run_command,
+                                           args=(command, ))
+        producer_thread.start()
+
+        responses = defaultdict(list)
+        ordered_nodes = []
+        active_node = None
+
+        while True:
+            try:
+                item = self.local_dict.get('graph').searcher_resp_queue.get(
+                    timeout=60)
+                if item is WebSearchGraph.end_signal:
+                    for node_name in ordered_nodes:
+                        # resp = None
+                        for resp in responses[node_name]:
+                            yield deepcopy(resp)
+                        # if resp:
+                        #     assert resp[1][
+                        #         'detail'].state == AgentStatusCode.END
+                    break
+                node_name, node, adj = item
+                if node_name in ['root', 'response']:
+                    yield deepcopy((node_name, node, adj))
+                else:
+                    if node_name not in ordered_nodes:
+                        ordered_nodes.append(node_name)
+                    responses[node_name].append((node_name, node, adj))
+                    if not active_node and ordered_nodes:
+                        active_node = ordered_nodes[0]
+                    while active_node and responses[active_node]:
+                        if return_early:
+                            if 'detail' in responses[active_node][-1][
+                                    1] and responses[active_node][-1][1][
+                                        'detail'].state == AgentStatusCode.END:
+                                item = responses[active_node][-1]
+                            else:
+                                item = responses[active_node].pop(0)
+                        else:
+                            item = responses[active_node].pop(0)
+                        if 'detail' in item[1] and item[1][
+                                'detail'].state == AgentStatusCode.END:
+                            ordered_nodes.pop(0)
+                            responses[active_node].clear()
+                            active_node = None
+                        yield deepcopy(item)
+            except queue.Empty:
+                if not producer_thread.is_alive():
+                    break
+        producer_thread.join()
+        return

mindsearch/agent/mindsearch_prompt.py

@@ -0,0 +1,267 @@
+# flake8: noqa
+
+searcher_system_prompt_cn = """## 人物简介
+你是一个可以调用网络搜索工具的智能助手。请根据"当前问题"，调用搜索工具收集信息并回复问题。你能够调用如下工具:
+{tool_info}
+## 回复格式
+
+调用工具时，请按照以下格式:
+```
+你的思考过程...<|action_start|><|plugin|>{{"name": "tool_name", "parameters": {{"param1": "value1"}}}}<|action_end|>
+```
+
+## 要求
+
+- 回答中每个关键点需标注引用的搜索结果来源，以确保信息的可信度。给出索引的形式为`[[int]]`，如果有多个索引，则用多个[[]]表示，如`[[id_1]][[id_2]]`。
+- 基于"当前问题"的搜索结果，撰写详细完备的回复，优先回答"当前问题"。
+
+"""
+
+searcher_system_prompt_en = """## Character Introduction
+You are an intelligent assistant that can call web search tools. Please collect information and reply to the question based on the current problem. You can use the following tools:
+{tool_info}
+## Reply Format
+
+When calling the tool, please follow the format below:
+```
+Your thought process...<|action_start|><|plugin|>{{"name": "tool_name", "parameters": {{"param1": "value1"}}}}<|action_end|>
+```
+
+## Requirements
+
+- Each key point in the response should be marked with the source of the search results to ensure the credibility of the information. The citation format is `[[int]]`. If there are multiple citations, use multiple [[]] to provide the index, such as `[[id_1]][[id_2]]`.
+- Based on the search results of the "current problem", write a detailed and complete reply to answer the "current problem".
+"""
+
+searcher_input_template_en = """## Final Problem
+{topic}
+## Current Problem
+{question}
+"""
+
+searcher_input_template_cn = """## 主问题
+{topic}
+## 当前问题
+{question}
+"""
+
+searcher_context_template_en = """## Historical Problem
+{question}
+Answer: {answer}
+"""
+
+searcher_context_template_cn = """## 历史问题
+{question}
+回答：{answer}
+"""
+
+search_template_cn = '## {query}\n\n{result}\n'
+search_template_en = '## {query}\n\n{result}\n'
+
+GRAPH_PROMPT_CN = """## 人物简介
+你是一个可以利用 Jupyter 环境 Python 编程的程序员。你可以利用提供的 API 来构建 Web 搜索图，最终生成代码并执行。
+
+## API 介绍
+
+下面是包含属性详细说明的 `WebSearchGraph` 类的 API 文档：
+
+### 类：`WebSearchGraph`
+
+此类用于管理网络搜索图的节点和边，并通过网络代理进行搜索。
+
+#### 初始化方法
+
+初始化 `WebSearchGraph` 实例。
+
+**属性：**
+
+- `nodes` (Dict[str, Dict[str, str]]): 存储图中所有节点的字典。每个节点由其名称索引，并包含内容、类型以及其他相关信息。
+- `adjacency_list` (Dict[str, List[str]]): 存储图中所有节点之间连接关系的邻接表。每个节点由其名称索引，并包含一个相邻节点名称的列表。
+
+
+#### 方法：`add_root_node`
+
+添加原始问题作为根节点。
+**参数：**
+
+- `node_content` (str): 用户提出的问题。
+- `node_name` (str, 可选): 节点名称，默认为 'root'。
+
+
+#### 方法：`add_node`
+
+添加搜索子问题节点并返回搜索结果。
+**参数：
+
+- `node_name` (str): 节点名称。
+- `node_content` (str): 子问题内容。
+
+**返回：**
+
+- `str`: 返回搜索结果。
+
+
+#### 方法：`add_response_node`
+
+当前获取的信息已经满足问题需求，添加回复节点。
+
+**参数：**
+
+- `node_name` (str, 可选): 节点名称，默认为 'response'。
+
+
+#### 方法：`add_edge`
+
+添加边。
+
+**参数：**
+
+- `start_node` (str): 起始节点名称。
+- `end_node` (str): 结束节点名称。
+
+
+#### 方法：`reset`
+
+重置节点和边。
+
+
+#### 方法：`node`
+
+获取节点信息。
+
+```python
+def node(self, node_name: str) -> str
+```
+
+**参数：**
+
+- `node_name` (str): 节点名称。
+
+**返回：**
+
+- `str`: 返回包含节点信息的字典，包含节点的内容、类型、思考过程（如果有）和前驱节点列表。
+
+## 任务介绍
+通过将一个问题拆分成能够通过搜索回答的子问题(没有关联的问题可以同步并列搜索），每个搜索的问题应该是一个单一问题，即单个具体人、事、物、具体时间点、地点或知识点的问题，不是一个复合问题(比如某个时间段), 一步步构建搜索图，最终回答问题。
+
+## 注意事项
+
+1. 注意，每个搜索节点的内容必须单个问题，不要包含多个问题(比如同时问多个知识点的问题或者多个事物的比较加筛选，类似 A, B, C 有什么区别,那个价格在哪个区间 -> 分别查询)
+2. 不要杜撰搜索结果，要等待代码返回结果
+3. 同样的问题不要重复提问，可以在已有问题的基础上继续提问
+4. 添加 response 节点的时候，要单独添加，不要和其他节点一起添加，不能同时添加 response 节点和其他节点
+5. 一次输出中，不要包含多个代码块，每次只能有一个代码块
+6. 每个代码块应该放置在一个代码块标记中，同时生成完代码后添加一个<end>标志，如下所示：
+    <|action_start|><|interpreter|>```python
+    # 你的代码块
+    ```<|action_end|>
+7. 最后一次回复应该是添加 response 节点，必须添加 response 节点，不要添加其他节点
+"""
+
+GRAPH_PROMPT_EN = """## Character Profile
+You are a programmer capable of Python programming in a Jupyter environment. You can utilize the provided API to construct a Web Search Graph, ultimately generating and executing code.
+
+## API Description
+
+Below is the API documentation for the WebSearchGraph class, including detailed attribute descriptions:
+
+### Class: WebSearchGraph
+
+This class manages nodes and edges of a web search graph and conducts searches via a web proxy.
+
+#### Initialization Method
+
+Initializes an instance of WebSearchGraph.
+
+**Attributes:**
+
+- nodes (Dict[str, Dict[str, str]]): A dictionary storing all nodes in the graph. Each node is indexed by its name and contains content, type, and other related information.
+- adjacency_list (Dict[str, List[str]]): An adjacency list storing the connections between all nodes in the graph. Each node is indexed by its name and contains a list of adjacent node names.
+
+#### Method: add_root_node
+
+Adds the initial question as the root node.
+**Parameters:**
+
+- node_content (str): The user's question.
+- node_name (str, optional): The node name, default is 'root'.
+
+#### Method: add_node
+
+Adds a sub-question node and returns search results.
+**Parameters:**
+
+- node_name (str): The node name.
+- node_content (str): The sub-question content.
+
+**Returns:**
+
+- str: Returns the search results.
+
+#### Method: add_response_node
+
+Adds a response node when the current information satisfies the question's requirements.
+
+**Parameters:**
+
+- node_name (str, optional): The node name, default is 'response'.
+
+#### Method: add_edge
+
+Adds an edge.
+
+**Parameters:**
+
+- start_node (str): The starting node name.
+- end_node (str): The ending node name.
+
+#### Method: reset
+
+Resets nodes and edges.
+
+#### Method: node
+
+Retrieves node information.
+
+python
+def node(self, node_name: str) -> str
+
+**Parameters:**
+
+- node_name (str): The node name.
+
+**Returns:**
+
+- str: Returns a dictionary containing the node's information, including content, type, thought process (if any), and list of predecessor nodes.
+
+## Task Description
+By breaking down a question into sub-questions that can be answered through searches (unrelated questions can be searched concurrently), each search query should be a single question focusing on a specific person, event, object, specific time point, location, or knowledge point. It should not be a compound question (e.g., a time period). Step by step, build the search graph to finally answer the question.
+
+## Considerations
+
+1. Each search node's content must be a single question; do not include multiple questions (e.g., do not ask multiple knowledge points or compare and filter multiple things simultaneously, like asking for differences between A, B, and C, or price ranges -> query each separately).
+2. Do not fabricate search results; wait for the code to return results.
+3. Do not repeat the same question; continue asking based on existing questions.
+4. When adding a response node, add it separately; do not add a response node and other nodes simultaneously.
+5. In a single output, do not include multiple code blocks; only one code block per output.
+6. Each code block should be placed within a code block marker, and after generating the code, add an <end> tag as shown below:
+    <|action_start|><|interpreter|>
+    ```python
+    # Your code block
+    ```<|action_end|>
+7. The final response should add a response node, and no other nodes should be added.
+"""
+
+FINAL_RESPONSE_CN = """基于提供的问答对，撰写一篇详细完备的最终回答。
+- 回答内容需要逻辑清晰，层次分明，确保读者易于理解。
+- 回答中每个关键点需标注引用的搜索结果来源(保持跟问答对中的索引一致)，以确保信息的可信度。给出索引的形式为`[[int]]`，如果有多个索引，则用多个[[]]表示，如`[[id_1]][[id_2]]`。
+- 回答部分需要全面且完备，不要出现"基于上述内容"等模糊表达，最终呈现的回答不包括提供给你的问答对。
+- 语言风格需要专业、严谨，避免口语化表达。
+- 保持统一的语法和词汇使用，确保整体文档的一致性和连贯性。"""
+
+FINAL_RESPONSE_EN = """Based on the provided Q&A pairs, write a detailed and comprehensive final response.
+- The response content should be logically clear and well-structured to ensure reader understanding.
+- Each key point in the response should be marked with the source of the search results (consistent with the indices in the Q&A pairs) to ensure information credibility. The index is in the form of `[[int]]`, and if there are multiple indices, use multiple `[[]]`, such as `[[id_1]][[id_2]]`.
+- The response should be comprehensive and complete, without vague expressions like "based on the above content". The final response should not include the Q&A pairs provided to you.
+- The language style should be professional and rigorous, avoiding colloquial expressions.
+- Maintain consistent grammar and vocabulary usage to ensure overall document consistency and coherence."""

mindsearch/agent/models.py

@@ -0,0 +1,44 @@
+import os
+
+from lagent.llms import (GPTAPI, INTERNLM2_META, HFTransformerCasualLM,
+                         LMDeployClient, LMDeployServer)
+
+internlm_server = dict(type=LMDeployServer,
+                       path='internlm/internlm2_5-7b-chat',
+                       model_name='internlm2',
+                       meta_template=INTERNLM2_META,
+                       top_p=0.8,
+                       top_k=1,
+                       temperature=0,
+                       max_new_tokens=8192,
+                       repetition_penalty=1.02,
+                       stop_words=['<|im_end|>'])
+
+internlm_client = dict(type=LMDeployClient,
+                       model_name='internlm2_5-7b-chat',
+                       url='http://127.0.0.1:23333',
+                       meta_template=INTERNLM2_META,
+                       top_p=0.8,
+                       top_k=1,
+                       temperature=0,
+                       max_new_tokens=8192,
+                       repetition_penalty=1.02,
+                       stop_words=['<|im_end|>'])
+
+internlm_hf = dict(type=HFTransformerCasualLM,
+                   path='internlm/internlm2_5-7b-chat',
+                   meta_template=INTERNLM2_META,
+                   top_p=0.8,
+                   top_k=None,
+                   temperature=1e-6,
+                   max_new_tokens=8192,
+                   repetition_penalty=1.02,
+                   stop_words=['<|im_end|>'])
+
+gpt4 = dict(type=GPTAPI,
+            model_type='gpt-4-turbo',
+            key=os.environ.get('OPENAI_API_KEY', 'YOUR OPENAI API KEY'))
+deepseek_coder = dict(type=GPTAPI,
+            model_type='deepseek-coder',
+            key=os.environ.get('OPENAI_API_KEY', 'YOUR OPENAI API KEY'),
+            url="https://api.deepseek.com")

mindsearch/app.py

@@ -0,0 +1,119 @@
+import asyncio
+import json
+import logging
+from copy import deepcopy
+from dataclasses import asdict
+from typing import Dict, List, Union
+
+import janus
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from lagent.schema import AgentStatusCode
+from pydantic import BaseModel
+from sse_starlette.sse import EventSourceResponse
+
+from mindsearch.agent import init_agent
+
+
+def parse_arguments():
+    import argparse
+    parser = argparse.ArgumentParser(description='MindSearch API')
+    parser.add_argument('--lang', default='cn', type=str, help='Language')
+    parser.add_argument('--model_format',
+                        default='internlm_server',
+                        type=str,
+                        help='Model format')
+    return parser.parse_args()
+
+
+args = parse_arguments()
+app = FastAPI(docs_url='/')
+
+app.add_middleware(CORSMiddleware,
+                   allow_origins=['*'],
+                   allow_credentials=True,
+                   allow_methods=['*'],
+                   allow_headers=['*'])
+
+
+class GenerationParams(BaseModel):
+    inputs: Union[str, List[Dict]]
+    agent_cfg: Dict = dict()
+
+
+@app.post('/solve')
+async def run(request: GenerationParams):
+
+    def convert_adjacency_to_tree(adjacency_input, root_name):
+
+        def build_tree(node_name):
+            node = {'name': node_name, 'children': []}
+            if node_name in adjacency_input:
+                for child in adjacency_input[node_name]:
+                    child_node = build_tree(child['name'])
+                    child_node['state'] = child['state']
+                    child_node['id'] = child['id']
+                    node['children'].append(child_node)
+            return node
+
+        return build_tree(root_name)
+
+    async def generate():
+        try:
+            queue = janus.Queue()
+
+            # 使用 run_in_executor 将同步生成器包装成异步生成器
+            def sync_generator_wrapper():
+                try:
+                    for response in agent.stream_chat(inputs):
+                        queue.sync_q.put(response)
+                except KeyError as e:
+                    logging.error(f'KeyError in sync_generator_wrapper: {e}')
+
+            async def async_generator_wrapper():
+                loop = asyncio.get_event_loop()
+                loop.run_in_executor(None, sync_generator_wrapper)
+                while True:
+                    response = await queue.async_q.get()
+                    yield response
+                    if not isinstance(
+                            response,
+                            tuple) and response.state == AgentStatusCode.END:
+                        break
+
+            async for response in async_generator_wrapper():
+                if isinstance(response, tuple):
+                    agent_return, node_name = response
+                else:
+                    agent_return = response
+                    node_name = None
+                origin_adj = deepcopy(agent_return.adjacency_list)
+                adjacency_list = convert_adjacency_to_tree(
+                    agent_return.adjacency_list, 'root')
+                assert adjacency_list[
+                    'name'] == 'root' and 'children' in adjacency_list
+                agent_return.adjacency_list = adjacency_list['children']
+                agent_return = asdict(agent_return)
+                agent_return['adj'] = origin_adj
+                response_json = json.dumps(dict(response=agent_return,
+                                                current_node=node_name),
+                                           ensure_ascii=False)
+                yield {'data': response_json}
+                # yield f'data: {response_json}\n\n'
+        except Exception as exc:
+            msg = 'An error occurred while generating the response.'
+            logging.exception(msg)
+            response_json = json.dumps(
+                dict(error=dict(msg=msg, details=str(exc))),
+                ensure_ascii=False)
+            yield {'data': response_json}
+            # yield f'data: {response_json}\n\n'
+
+    inputs = request.inputs
+    agent = init_agent(lang=args.lang, model_format=args.model_format)
+    return EventSourceResponse(generate())
+
+
+if __name__ == '__main__':
+    import uvicorn
+    uvicorn.run(app, host='0.0.0.0', port=8002, log_level='info')

mindsearch/terminal.py

@@ -0,0 +1,50 @@
+from datetime import datetime
+
+from lagent.actions import ActionExecutor, BingBrowser
+from lagent.llms import INTERNLM2_META, LMDeployServer
+
+from mindsearch.agent.mindsearch_agent import (MindSearchAgent,
+                                               MindSearchProtocol)
+from mindsearch.agent.mindsearch_prompt import (
+    FINAL_RESPONSE_CN, FINAL_RESPONSE_EN, GRAPH_PROMPT_CN, GRAPH_PROMPT_EN,
+    searcher_context_template_cn, searcher_context_template_en,
+    searcher_input_template_cn, searcher_input_template_en,
+    searcher_system_prompt_cn, searcher_system_prompt_en)
+
+lang = 'cn'
+llm = LMDeployServer(path='internlm/internlm2_5-7b',
+                     model_name='internlm2',
+                     meta_template=INTERNLM2_META,
+                     top_p=0.8,
+                     top_k=1,
+                     temperature=0,
+                     max_new_tokens=8192,
+                     repetition_penalty=1.02,
+                     stop_words=['<|im_end|>'])
+
+agent = MindSearchAgent(
+    llm=llm,
+    protocol=MindSearchProtocol(
+        meta_prompt=datetime.now().strftime('The current date is %Y-%m-%d.'),
+        interpreter_prompt=GRAPH_PROMPT_CN
+        if lang == 'cn' else GRAPH_PROMPT_EN,
+        response_prompt=FINAL_RESPONSE_CN
+        if lang == 'cn' else FINAL_RESPONSE_EN),
+    searcher_cfg=dict(
+        llm=llm,
+        plugin_executor=ActionExecutor(
+            BingBrowser(searcher_type='DuckDuckGoSearch', topk=6)),
+        protocol=MindSearchProtocol(
+            meta_prompt=datetime.now().strftime(
+                'The current date is %Y-%m-%d.'),
+            plugin_prompt=searcher_system_prompt_cn
+            if lang == 'cn' else searcher_system_prompt_en,
+        ),
+        template=dict(input=searcher_input_template_cn
+                      if lang == 'cn' else searcher_input_template_en,
+                      context=searcher_context_template_cn
+                      if lang == 'cn' else searcher_context_template_en)),
+    max_turn=10)
+
+for agent_return in agent.stream_chat('上海今天适合穿什么衣服'):
+    pass

requirements.txt

@@ -0,0 +1,11 @@
+duckduckgo_search==5.3.1b1
+einops
+fastapi
+git+https://github.com/InternLM/lagent.git
+gradio
+janus
+lmdeploy==0.2.3
+pyvis
+sse-starlette
+termcolor
+uvicorn