xinference 1.7.0.post1__py3-none-any.whl → 1.7.1.post1__py3-none-any.whl

xinference/model/llm/vllm/core.py

@@ -51,6 +51,7 @@ from ....types import (
     LoRA,
 )
 from .. import LLM, LLMFamilyV1, LLMSpecV1
+from ..core import chat_context_var
 from ..llm_family import CustomLLMFamilyV1, cache_model_tokenizer_and_config
 from ..utils import (
     DEEPSEEK_TOOL_CALL_FAMILY,
@@ -241,6 +242,7 @@ if VLLM_INSTALLED and vllm.__version__ >= "0.7.2":
 
 if VLLM_INSTALLED and vllm.__version__ >= "0.7.3":
     VLLM_SUPPORTED_CHAT_MODELS.append("qwen2.5-instruct-1m")
+    VLLM_SUPPORTED_CHAT_MODELS.append("qwenLong-l1")
 
 if VLLM_INSTALLED and vllm.__version__ >= "0.8.0":
     VLLM_SUPPORTED_CHAT_MODELS.append("gemma-3-1b-it")
@@ -332,6 +334,7 @@ class VLLMModel(LLM):
     def load(self):
         try:
             import vllm
+            from vllm import envs
             from vllm.config import VllmConfig
             from vllm.engine.arg_utils import AsyncEngineArgs
             from vllm.engine.async_llm_engine import AsyncLLMEngine
@@ -414,8 +417,6 @@ class VLLMModel(LLM):
         elif self._n_worker > 1 or (
             self._device_count > 1 and vllm.__version__ >= "0.7.0"
         ):
-            from .distributed_executor import XinferenceDistributedExecutor
-
             # model across multiple workers or GPUs
             engine_args = AsyncEngineArgs(
                 model=self.model_path,
@@ -423,6 +424,7 @@ class VLLMModel(LLM):
                 max_loras=max_loras,
                 **self._model_config,
             )
+            self._enable_v1_if_supported(engine_args)
 
             assert self._loop is not None
             self._worker_addresses = {}
@@ -464,21 +466,47 @@ class VLLMModel(LLM):
                         assert worker_addresses
                         loop = self._loop
 
-                        class XinferenceAsyncLLMEngine(AsyncLLMEngine):
-                            @classmethod
-                            def _get_executor_cls(
-                                cls, engine_config: VllmConfig
-                            ) -> Type[ExecutorBase]:
-                                return partial(  # type: ignore
-                                    XinferenceDistributedExecutor,
-                                    pool_addresses=worker_addresses,
-                                    n_worker=self._n_worker,
-                                    loop=loop,
-                                )
-
-                        self._engine = XinferenceAsyncLLMEngine.from_engine_args(
-                            engine_args
-                        )
+                        if not (envs.is_set("VLLM_USE_V1") and envs.VLLM_USE_V1):
+                            # vLLM v0
+                            from .distributed_executor import (
+                                XinferenceDistributedExecutor,
+                            )
+
+                            class XinferenceAsyncLLMEngine(AsyncLLMEngine):
+                                @classmethod
+                                def _get_executor_cls(
+                                    cls, engine_config: VllmConfig
+                                ) -> Type[ExecutorBase]:
+                                    return partial(  # type: ignore
+                                        XinferenceDistributedExecutor,
+                                        pool_addresses=worker_addresses,
+                                        n_worker=self._n_worker,
+                                        loop=loop,
+                                    )
+
+                            self._engine = XinferenceAsyncLLMEngine.from_engine_args(
+                                engine_args
+                            )
+                        else:
+                            from vllm.v1.executor.abstract import Executor
+
+                            from .distributed_executor import (
+                                XinferenceDistributedExecutorV1,
+                            )
+
+                            # vLLM V1
+                            # NOTE: loop has to be None for vLLM v1
+                            # in v1, a new process called EngineCore will be created via fork by default
+                            # in which executor is initialized, we cannot pass loop, or it will be stuck,
+                            # instead, a new loop will be created inside executor
+                            executor_cls = partial(  # type: ignore
+                                XinferenceDistributedExecutorV1,
+                                pool_addresses=worker_addresses,
+                                n_worker=self._n_worker,
+                            )
+                            # patch vllm Executor.get_class
+                            Executor.get_class = lambda vllm_config: executor_cls
+                            self._engine = AsyncLLMEngine.from_engine_args(engine_args)
                 except:
                     logger.exception("Creating vllm engine failed")
                     self._loading_error = sys.exc_info()
@@ -495,6 +523,7 @@ class VLLMModel(LLM):
                 max_loras=max_loras,
                 **self._model_config,
             )
+            self._enable_v1_if_supported(engine_args)
             self._engine = AsyncLLMEngine.from_engine_args(engine_args)
 
         self._check_health_task = None
@@ -509,6 +538,46 @@ class VLLMModel(LLM):
                 _, err, tb = self._loading_error
                 raise err.with_traceback(tb)
 
+    def _enable_v1_if_supported(self, engine_args: "vllm.AsyncEngineArgs"):
+        from vllm import __version__ as vllm_version
+
+        if os.getenv("VLLM_USE_V1") is not None:
+            logger.debug(
+                "Setting vLLM v1 via environment variable already, skip checking"
+            )
+            return
+
+        try:
+            supported_func = engine_args._is_v1_supported_oracle
+        except AttributeError:
+            logger.debug(
+                "Cannot get `EngineArgs._is_v1_supported_oracle` "
+                "to decide enabling vLLM v1, perhaps vllm version is too old, "
+                "version: %s",
+                vllm_version,
+            )
+            return
+
+        model_config = engine_args.create_model_config()
+        old_main_thread = threading.main_thread()
+        try:
+            # HACK: patch main thread to let vllm pass check
+            # vllm do some signal handling when on main thread
+            # but they will skip registering signal if not on main thread,
+            # however, the _is_v1_supported_oracle will return False
+            # when not on main thread, we patched the main thread temporially,
+            # It's OK because Xinference will take care of all processes
+            threading.main_thread = lambda: threading.current_thread()
+
+            if supported_func(model_config):
+                logger.debug("Setting vLLM v1 by checking model config")
+                os.environ["VLLM_USE_V1"] = "1"
+            else:
+                logger.debug("Use vLLM v0 due to not supported config")
+        finally:
+            # patch back
+            threading.main_thread = lambda: old_main_thread
+
     def _preprocess_load_gguf(self):
         # check if it is multi gguf files
         if (
@@ -549,6 +618,8 @@ class VLLMModel(LLM):
             )
 
     def stop(self):
+        from vllm import envs
+
         # though the vLLM engine will shutdown when deleted,
         # but some issue e.g. GH#1682 reported
         # when deleting, the engine exists still
@@ -556,9 +627,17 @@ class VLLMModel(LLM):
         if self._check_health_task:
             self._check_health_task.cancel()
         if self._engine:
-            if model_executor := getattr(self._engine.engine, "model_executor", None):
-                model_executor.shutdown()
-            self._engine = None
+            if not (envs.is_set("VLLM_USE_V1") and envs.VLLM_USE_V1):
+                # v0
+                if model_executor := getattr(
+                    self._engine.engine, "model_executor", None
+                ):
+                    model_executor.shutdown()
+                self._engine = None
+            else:
+                # v1
+                self._engine.shutdown()
+                self._engine = None
 
     async def init_xavier(self):
         await self._engine.init_xavier()
@@ -602,7 +681,6 @@ class VLLMModel(LLM):
         else:
             model_config.setdefault("quantization", None)
         model_config.setdefault("max_model_len", None)
-        model_config.setdefault("guided_decoding_backend", "outlines")
         model_config.setdefault("reasoning_content", False)
         # Add scheduling policy if vLLM version is 0.6.3 or higher
         if vllm.__version__ >= "0.6.3":
@@ -960,6 +1038,16 @@ class VLLMModel(LLM):
                 assert chunk is not None
                 yield chunk
 
+            logger.info(
+                "Generate finished, request_id: %s, stop reason: %s, prompt tokens: %s, "
+                "completion tokens: %s, all tokens: %s",
+                request_id,
+                finish_reason,
+                prompt_tokens,
+                completion_tokens,
+                total_tokens,
+            )
+
             # match OpenAI API stream
             yield generate_completion_chunk(
                 chunk_text="",
@@ -1055,17 +1143,23 @@ class VLLMChatModel(VLLMModel, ChatModelMixin):
         return generate_config
 
     @staticmethod
-    def is_tool_call_chunk(chunk):
+    def is_tool_call_chunk_start(chunk):
         return chunk["choices"][0]["text"].startswith(QWEN_TOOL_CALL_SYMBOLS[0])
 
+    @staticmethod
+    def is_tool_call_chunk_end(chunk):
+        return chunk["choices"][0]["text"].endswith(QWEN_TOOL_CALL_SYMBOLS[1])
+
     async def _async_to_tool_completion_chunks(
         self,
         chunks: AsyncGenerator[CompletionChunk, None],
     ) -> AsyncGenerator[ChatCompletionChunk, None]:
         i = 0
         previous_texts = [""]
+        tool_call = False
+        tool_call_texts = [""]
         if self.reasoning_parser:
-            chunks = self.reasoning_parser.prepare_reasoning_content(chunks)
+            chunks = self.reasoning_parser.prepare_reasoning_content_streaming(chunks)
         async for chunk in chunks:
             if i == 0:
                 for first_chunk in self._get_first_chat_completion_chunk(
@@ -1077,13 +1171,22 @@ class VLLMChatModel(VLLMModel, ChatModelMixin):
             if not choices:
                 yield self._get_final_chat_completion_chunk(chunk)
             else:
-                if self.is_tool_call_chunk(chunk):
-                    yield self._post_process_completion_chunk(
-                        self.model_family,
-                        self.model_uid,
-                        chunk,
-                        reasoning_parser=self.reasoning_parser,
-                    )
+                if self.is_tool_call_chunk_start(chunk):
+                    tool_call = True
+                if tool_call:
+                    tool_call_text = tool_call_texts[-1]
+                    tool_call_text += chunk["choices"][0]["text"]
+                    tool_call_texts.append(tool_call_text)
+                    if self.is_tool_call_chunk_end(chunk):
+                        yield self._post_process_completion_chunk(
+                            self.model_family,
+                            self.model_uid,
+                            chunk,
+                            reasoning_parser=self.reasoning_parser,
+                            tool_call_text=tool_call_text,
+                        )
+                        tool_call = False
+                        tool_call_texts = [""]
                 else:
                     yield self._to_chat_completion_chunk(
                         chunk, self.reasoning_parser, previous_texts
@@ -1099,12 +1202,14 @@ class VLLMChatModel(VLLMModel, ChatModelMixin):
     ) -> Union[ChatCompletion, AsyncGenerator[ChatCompletionChunk, None]]:
         tools = generate_config.pop("tools", []) if generate_config else None
         model_family = self.model_family.model_family or self.model_family.model_name
-        full_context_kwargs = (
+        chat_template_kwargs = (
             self._get_chat_template_kwargs_from_generate_config(
                 generate_config, self.reasoning_parser
             )
             or {}
         )
+        chat_context_var.set(chat_template_kwargs)
+        full_context_kwargs = chat_template_kwargs.copy()
         if tools:
             if (
                 model_family in QWEN_TOOL_CALL_FAMILY
@@ -1214,20 +1319,23 @@ class VLLMVisionModel(VLLMModel, ChatModelMixin):
         generate_config: Optional[Dict] = None,
         request_id: Optional[str] = None,
     ) -> Union[ChatCompletion, AsyncGenerator[ChatCompletionChunk, None]]:
-        messages = self._transform_messages(messages)
         tools = generate_config.pop("tools", []) if generate_config else None
 
         model_family = self.model_family.model_family or self.model_family.model_name
 
-        if "internvl2" not in model_family.lower():
+        if "internvl" not in model_family.lower():
             from qwen_vl_utils import process_vision_info
 
-            full_context_kwargs = (
+            messages = self._transform_messages(messages)
+
+            chat_template_kwargs = (
                 self._get_chat_template_kwargs_from_generate_config(
                     generate_config, self.reasoning_parser
                 )
                 or {}
             )
+            chat_context_var.set(chat_template_kwargs)
+            full_context_kwargs = chat_template_kwargs.copy()
             if tools and model_family in QWEN_TOOL_CALL_FAMILY:
                 full_context_kwargs["tools"] = tools
             assert self.model_family.chat_template is not None

xinference/model/llm/vllm/distributed_executor.py

@@ -19,11 +19,19 @@ from functools import partial
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union
 
 import xoscar as xo
+from vllm import envs
 from vllm.executor.executor_base import DistributedExecutorBase
 from vllm.utils import _run_task_with_lock, get_distributed_init_method
 from vllm.worker.worker_base import WorkerWrapperBase
 from xoscar.utils import get_next_port
 
+try:
+    from vllm.v1.executor.abstract import Executor as ExecutorV1
+except ImportError:
+    ExecutorV1 = None
+
+from ....isolation import Isolation
+
 if TYPE_CHECKING:
     from vllm.config import VllmConfig
     from vllm.model_executor.layers.sampler import SamplerOutput
@@ -31,6 +39,8 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+DEBUG_EXECUTOR = bool(int(os.getenv("XINFERENCE_DEBUG_VLLM_EXECUTOR", "0")))
+
 
 class WorkerActor(xo.StatelessActor):
     def __init__(self, vllm_config: "VllmConfig", rpc_rank: int = 0, **kwargs):
@@ -54,14 +64,15 @@ class WorkerActor(xo.StatelessActor):
         return f"VllmWorker_{rank}"
 
     def execute_method(self, method: Union[str, Callable], *args, **kwargs):
-        # NOTE: too many logs, but useful for debug
-        # logger.debug(
-        #     "Calling method %s in vllm worker %s, args: %s, kwargs: %s",
-        #     method,
-        #     self.uid,
-        #     args,
-        #     kwargs,
-        # )
+        if DEBUG_EXECUTOR:
+            # NOTE: too many logs, but useful for debug
+            logger.debug(
+                "Calling method %s in vllm worker %s, args: %s, kwargs: %s",
+                method,
+                self.uid,
+                args,
+                kwargs,
+            )
         if isinstance(method, str):
             return getattr(self._worker, method)(*args, **kwargs)
         else:
@@ -92,7 +103,7 @@ class WorkerWrapper:
 class XinferenceDistributedExecutor(DistributedExecutorBase):
     """Xoscar based distributed executor"""
 
-    use_ray: bool = False
+    uses_ray: bool = False
     _loop: asyncio.AbstractEventLoop
     _pool_addresses: List[str]
     _n_worker: int
@@ -112,15 +123,27 @@ class XinferenceDistributedExecutor(DistributedExecutorBase):
         self._is_shutdown = False
         super().__init__(vllm_config, *args, **kwargs)
 
+    def _create_workers(self, refs: xo.ActorRefType[WorkerActor]) -> None:
+        self.driver_worker: Optional[WorkerActor] = None
+        # The remaining workers are Xoscar actors
+        self.workers: List[WorkerWrapper] = []
+
+        self.workers = [WorkerWrapper(self._loop, ref) for ref in refs[1:]]
+
+        # driver worker only for vllm v0
+        self.driver_worker = WorkerActor(self.vllm_config, rpc_rank=0)
+
+        def driver_execute_method(*args, **kwargs):
+            func = partial(self.driver_worker.execute_method, *args, **kwargs)
+            return self._loop.run_in_executor(None, func)
+
+        self.driver_exec_method = driver_execute_method
+
     def _init_executor(self) -> None:
         # Create the parallel GPU workers.
         world_size = self.parallel_config.world_size
         tensor_parallel_size = self.parallel_config.tensor_parallel_size
 
-        self.driver_worker: Optional[WorkerActor] = None
-        # The remaining workers are Xoscar actors
-        self.workers: List[WorkerWrapper] = []
-
         assert (
             self._pool_addresses and len(self._pool_addresses) == world_size
         ), f"Pool addresses(#{len(self._pool_addresses or [])} must be equal to worldsize(#{world_size})"
@@ -135,15 +158,10 @@ class XinferenceDistributedExecutor(DistributedExecutorBase):
                 uid=WorkerActor.gen_uid(rank),
             )
             futures.append(asyncio.run_coroutine_threadsafe(coro, self._loop))
-        refs = [fut.result() for fut in futures]
-        self.workers = [WorkerWrapper(self._loop, ref) for ref in refs[1:]]
-        self.driver_worker = WorkerActor(self.vllm_config, rpc_rank=0)
-
-        def driver_execute_method(*args, **kwargs):
-            func = partial(self.driver_worker.execute_method, *args, **kwargs)
-            return self._loop.run_in_executor(None, func)
+        refs: List[xo.ActorRefType[WorkerActor]] = [fut.result() for fut in futures]
 
-        self.driver_exec_method = driver_execute_method
+        # create workers
+        self._create_workers(refs)
 
         # Set environment variables for the driver and workers.
         all_args_to_update_environment_variables: List[Dict[str, str]] = [
@@ -319,3 +337,60 @@ class XinferenceDistributedExecutor(DistributedExecutorBase):
             for worker in self.non_driver_workers
         ]
         return await asyncio.gather(*coros)
+
+
+if ExecutorV1:
+
+    class XinferenceDistributedExecutorV1(XinferenceDistributedExecutor, ExecutorV1):
+        def __init__(
+            self,
+            vllm_config: "VllmConfig",
+            pool_addresses: List[str],
+            n_worker: int,
+            *args,
+            **kwargs,
+        ):
+            assert envs.VLLM_USE_V1
+
+            isolation = Isolation(asyncio.new_event_loop())
+            isolation.start()
+            loop = isolation.loop
+
+            XinferenceDistributedExecutor.__init__(
+                self, vllm_config, pool_addresses, n_worker, loop, *args, **kwargs
+            )
+
+        def _create_workers(self, refs: xo.ActorRefType[WorkerActor]) -> None:
+            self.workers = [WorkerWrapper(self._loop, ref) for ref in refs]
+
+        def execute_model(
+            self,
+            execute_model_req: "ExecuteModelRequest",
+        ) -> List["SamplerOutput"]:
+            outputs = self._run_workers("execute_model", execute_model_req)
+            return outputs[0]
+
+        def _run_workers(
+            self,
+            method: Union[str, Callable],
+            *args,
+            async_run_tensor_parallel_workers_only: bool = False,
+            max_concurrent_workers: Optional[int] = None,
+            **kwargs,
+        ) -> Any:
+            if max_concurrent_workers:
+                raise NotImplementedError(
+                    "max_concurrent_workers is not supported yet."
+                )
+
+            workers = self.workers
+            if async_run_tensor_parallel_workers_only:
+                workers = self.non_driver_workers
+            worker_outputs = [
+                worker.execute_method(method, *args, **kwargs) for worker in workers
+            ]
+
+            if async_run_tensor_parallel_workers_only:
+                return worker_outputs
+
+            return [output.result() for output in worker_outputs]

xinference/model/llm/vllm/xavier/transfer.py

@@ -31,8 +31,8 @@ logger = logging.getLogger(__name__)
 class BufferTransferMixin:
     def __init__(self):
         self.num_buffer: int = 0
-        self.buffers: List[torch.Tensor] = []
-        self.buffer_queue: Optional[Queue] = None
+        self.buffers: List[torch.Tensor] = []  # type: ignore
+        self.buffer_queue: Optional[Queue] = None  # type: ignore
         self.transfer_block_num = 0
         self.num_attn_layers = 0
 

xinference/model/rerank/core.py

@@ -252,11 +252,13 @@ class RerankModel:
             tokenizer = AutoTokenizer.from_pretrained(
                 self._model_path, padding_side="left"
             )
-            flash_attn_installed = importlib.util.find_spec("flash_attn") is not None
+            enable_flash_attn = self._model_config.get("enable_flash_attn", True)
             model_kwargs = {"device_map": "auto"}
-            if flash_attn_installed:
+            if flash_attn_installed and enable_flash_attn:
                 model_kwargs["attn_implementation"] = "flash_attention_2"
                 model_kwargs["torch_dtype"] = torch.float16
+            model_kwargs.update(self._model_config)
+            logger.debug("Loading qwen3 rerank with kwargs %s", model_kwargs)
             model = self._model = AutoModelForCausalLM.from_pretrained(
                 self._model_path, **model_kwargs
             ).eval()
@@ -368,13 +370,18 @@ class RerankModel:
                 )
                 return output
 
-            pairs = [
-                format_instruction(kwargs.get("instruction", None), query, doc)
-                for doc in documents
-            ]
-            # Tokenize the input texts
-            inputs = self.process_inputs(pairs)
-            similarity_scores = self.compute_logits(inputs)
+            # reduce memory usage.
+            micro_bs = 4
+            similarity_scores = []
+            for i in range(0, len(documents), micro_bs):
+                sub_docs = documents[i : i + micro_bs]
+                pairs = [
+                    format_instruction(kwargs.get("instruction", None), query, doc)
+                    for doc in sub_docs
+                ]
+                # Tokenize the input texts
+                inputs = self.process_inputs(pairs)
+                similarity_scores.extend(self.compute_logits(inputs))
         else:
             # Related issue: https://github.com/xorbitsai/inference/issues/1775
             similarity_scores = self._model.compute_score(

xinference/model/rerank/model_spec.json

@@ -67,7 +67,7 @@
     "model_name": "Qwen3-Reranker-0.6B",
     "type": "normal",
     "language": ["en", "zh"],
-    "max_tokens": 40960,
+    "max_tokens": 32768,
     "model_id": "Qwen/Qwen3-Reranker-0.6B",
     "model_revision": "6e9e69830b95c52b5fd889b7690dda3329508de3"
   },
@@ -75,7 +75,7 @@
     "model_name": "Qwen3-Reranker-4B",
     "type": "normal",
     "language": ["en", "zh"],
-    "max_tokens": 40960,
+    "max_tokens": 32768,
     "model_id": "Qwen/Qwen3-Reranker-4B",
     "model_revision": "f16fc5d5d2b9b1d0db8280929242745d79794ef5"
   },
@@ -83,7 +83,7 @@
     "model_name": "Qwen3-Reranker-8B",
     "type": "normal",
     "language": ["en", "zh"],
-    "max_tokens": 40960,
+    "max_tokens": 32768,
     "model_id": "Qwen/Qwen3-Reranker-8B",
     "model_revision": "5fa94080caafeaa45a15d11f969d7978e087a3db"
   }

xinference/model/rerank/model_spec_modelscope.json

@@ -62,7 +62,7 @@
     "model_name": "Qwen3-Reranker-0.6B",
     "type": "normal",
     "language": ["en", "zh"],
-    "max_tokens": 40960,
+    "max_tokens": 32768,
     "model_id": "Qwen/Qwen3-Reranker-0.6B",
     "model_hub": "modelscope"
   },
@@ -70,7 +70,7 @@
     "model_name": "Qwen3-Reranker-4B",
     "type": "normal",
     "language": ["en", "zh"],
-    "max_tokens": 40960,
+    "max_tokens": 32768,
     "model_id": "Qwen/Qwen3-Reranker-4B",
     "model_hub": "modelscope"
   },
@@ -78,7 +78,7 @@
     "model_name": "Qwen3-Reranker-8B",
     "type": "normal",
     "language": ["en", "zh"],
-    "max_tokens": 40960,
+    "max_tokens": 32768,
     "model_id": "Qwen/Qwen3-Reranker-8B",
     "model_hub": "modelscope"
   }

xinference/web/ui/build/asset-manifest.json

@@ -1,14 +1,14 @@
 {
   "files": {
     "main.css": "./static/css/main.013f296b.css",
-    "main.js": "./static/js/main.8a9e3ba0.js",
+    "main.js": "./static/js/main.9b12b7f9.js",
     "static/media/icon.webp": "./static/media/icon.4603d52c63041e5dfbfd.webp",
     "index.html": "./index.html",
     "main.013f296b.css.map": "./static/css/main.013f296b.css.map",
-    "main.8a9e3ba0.js.map": "./static/js/main.8a9e3ba0.js.map"
+    "main.9b12b7f9.js.map": "./static/js/main.9b12b7f9.js.map"
   },
   "entrypoints": [
     "static/css/main.013f296b.css",
-    "static/js/main.8a9e3ba0.js"
+    "static/js/main.9b12b7f9.js"
   ]
 }

xinference/web/ui/build/index.html

@@ -1 +1 @@
-<!doctype html><html lang="en"><head><meta charset="utf-8"/><link rel="icon" href="./favicon.svg"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><meta name="description" content="Web site created using create-react-app"/><link rel="apple-touch-icon" href="./logo192.png"/><link rel="manifest" href="./manifest.json"/><title>Xinference</title><script defer="defer" src="./static/js/main.8a9e3ba0.js"></script><link href="./static/css/main.013f296b.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>
+<!doctype html><html lang="en"><head><meta charset="utf-8"/><link rel="icon" href="./favicon.svg"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><meta name="description" content="Web site created using create-react-app"/><link rel="apple-touch-icon" href="./logo192.png"/><link rel="manifest" href="./manifest.json"/><title>Xinference</title><script defer="defer" src="./static/js/main.9b12b7f9.js"></script><link href="./static/css/main.013f296b.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>