xinference 0.10.0__py3-none-any.whl → 0.10.2__py3-none-any.whl

xinference/model/llm/pytorch/yi_vl.py

@@ -59,6 +59,8 @@ class YiVLChatModel(PytorchChatModel):
 
         self._device = self._pytorch_model_config.get("device", "auto")
         self._device = select_device(self._device)
+        # for multiple GPU, set back to auto to make multiple devices work
+        self._device = "auto" if self._device == "cuda" else self._device
 
         key_info["model_path"] = self.model_path
         # Default device_map is auto, it can loads model to multiple cards.
@@ -190,7 +192,7 @@ class YiVLChatModel(PytorchChatModel):
                 prompt, self._tokenizer, IMAGE_TOKEN_INDEX, return_tensors="pt"
             )
             .unsqueeze(0)
-            .to(self._device)
+            .to(self._model.device)
         )
 
         images = state.get_images(return_pil=True)
@@ -215,7 +217,7 @@ class YiVLChatModel(PytorchChatModel):
             "input_ids": input_ids,
             "images": image_tensor.unsqueeze(0)
             .to(dtype=torch.bfloat16)
-            .to(self._device),
+            .to(self._model.device),
             "streamer": streamer,
             "do_sample": True,
             "top_p": float(top_p),

xinference/model/llm/utils.py

@@ -163,7 +163,7 @@ class ChatModelMixin:
 
             for i, message in enumerate(chat_history):
                 role = get_role(message["role"])
-                content = message["content"]
+                content = message.get("content")
                 tool_calls = message.get("tool_calls")
                 if tool_calls:
                     content = tool_calls[0]["function"]
@@ -248,7 +248,7 @@ Begin!"""
             ret = f"<|im_start|>system\n{prompt_style.system_prompt}<|im_end|>"
             for message in chat_history:
                 role = get_role(message["role"])
-                content = message["content"]
+                content = message.get("content")
 
                 ret += prompt_style.intra_message_sep
                 if tools:
@@ -446,6 +446,11 @@ Begin!"""
                     "index": i,
                     "delta": {
                         "content": choice["text"],
+                        **(
+                            {"tool_calls": choice["tool_calls"]}
+                            if "tool_calls" in choice
+                            else {}
+                        ),
                     },
                     "finish_reason": choice["finish_reason"],
                 }
@@ -592,8 +597,7 @@ Begin!"""
         return text, None, None
 
     @classmethod
-    def _tool_calls_completion(cls, model_family, model_uid, c, tools):
-        _id = str(uuid.uuid4())
+    def _eval_tool_arguments(cls, model_family, c, tools):
         family = model_family.model_family or model_family.model_name
         if family in ["gorilla-openfunctions-v1", "gorilla-openfunctions-v2"]:
             content, func, args = cls._eval_gorilla_openfunctions_arguments(c, tools)
@@ -606,7 +610,41 @@ Begin!"""
                 f"Model {model_family.model_name} is not support tool calls."
             )
         logger.debug("Tool call content: %s, func: %s, args: %s", content, func, args)
+        return content, func, args
+
+    @classmethod
+    def _tools_token_filter(cls, model_family):
+        """
+        Generates a filter function for Qwen series models to retain outputs after "\nFinal Answer:".
 
+        Returns:
+            A function that takes tokens (string output by the model so far) as input
+            returns True if current token is after "\nFinal Answer:", else False.
+        """
+        family = model_family.model_family or model_family.model_name
+        if family in ["qwen-chat", "qwen1.5-chat"]:
+            # Encapsulating function to reset 'found' after each call
+            found = False
+
+            def process_token(tokens: str):
+                nonlocal found
+                # Once "Final Answer:" is found, future tokens are allowed.
+                if found:
+                    return True
+                # Check if the token ends with "\nFinal Answer:" and update `found`.
+                if tokens.endswith("\nFinal Answer:"):
+                    found = True
+                return False
+
+            return process_token
+        else:
+            # For other families, allow all tokens.
+            return lambda tokens: True
+
+    @classmethod
+    def _tool_calls_completion(cls, model_family, model_uid, c, tools):
+        _id = str(uuid.uuid4())
+        content, func, args = cls._eval_tool_arguments(model_family, c, tools)
         if func:
             m = {
                 "role": "assistant",

xinference/model/llm/vllm/core.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import json
 import logging
 import multiprocessing
 import time
@@ -36,6 +37,8 @@ from ....types import (
     CompletionChoice,
     CompletionChunk,
     CompletionUsage,
+    ToolCallFunction,
+    ToolCalls,
 )
 from .. import LLM, LLMFamilyV1, LLMSpecV1
 from ..llm_family import CustomLLMFamilyV1
@@ -80,7 +83,15 @@ try:
 except ImportError:
     VLLM_INSTALLED = False
 
-VLLM_SUPPORTED_MODELS = ["llama-2", "baichuan", "internlm-16k", "mistral-v0.1"]
+VLLM_SUPPORTED_MODELS = [
+    "llama-2",
+    "baichuan",
+    "internlm-16k",
+    "mistral-v0.1",
+    "Yi",
+    "code-llama",
+    "code-llama-python",
+]
 VLLM_SUPPORTED_CHAT_MODELS = [
     "llama-2-chat",
     "vicuna-v1.3",
@@ -90,21 +101,22 @@ VLLM_SUPPORTED_CHAT_MODELS = [
     "internlm-chat-7b",
     "internlm-chat-8k",
     "internlm-chat-20b",
+    "internlm2-chat",
     "qwen-chat",
-    "Yi",
     "Yi-chat",
-    "code-llama",
-    "code-llama-python",
     "code-llama-instruct",
     "mistral-instruct-v0.1",
     "mistral-instruct-v0.2",
     "mixtral-instruct-v0.1",
     "chatglm3",
+    "chatglm3-32k",
+    "chatglm3-128k",
     "deepseek-chat",
     "deepseek-coder-instruct",
 ]
 if VLLM_INSTALLED and vllm.__version__ >= "0.3.0":
     VLLM_SUPPORTED_CHAT_MODELS.append("qwen1.5-chat")
+    VLLM_SUPPORTED_CHAT_MODELS.append("codeqwen1.5-chat")
 
 if VLLM_INSTALLED and vllm.__version__ >= "0.3.2":
     VLLM_SUPPORTED_CHAT_MODELS.append("gemma-it")
@@ -113,6 +125,11 @@ if VLLM_INSTALLED and vllm.__version__ >= "0.3.3":
     VLLM_SUPPORTED_CHAT_MODELS.append("orion-chat")
     VLLM_SUPPORTED_CHAT_MODELS.append("orion-chat-rag")
 
+if VLLM_INSTALLED and vllm.__version__ >= "0.4.0":
+    VLLM_SUPPORTED_CHAT_MODELS.append("qwen1.5-moe-chat")
+    VLLM_SUPPORTED_MODELS.append("c4ai-command-r-v01")
+    VLLM_SUPPORTED_MODELS.append("c4ai-command-r-v01-4bit")
+
 
 class VLLMModel(LLM):
     def __init__(
@@ -293,6 +310,7 @@ class VLLMModel(LLM):
         self,
         prompt: str,
         generate_config: Optional[Dict] = None,
+        tools: object = False,
     ) -> Union[Completion, AsyncGenerator[CompletionChunk, None]]:
         try:
             from vllm.sampling_params import SamplingParams
@@ -319,16 +337,46 @@ class VLLMModel(LLM):
 
         async def stream_results() -> AsyncGenerator[CompletionChunk, None]:
             previous_texts = [""] * sanitized_generate_config["n"]
+            tools_token_filter = ChatModelMixin._tools_token_filter(self.model_family)
             async for _request_output in results_generator:
                 chunk = self._convert_request_output_to_completion_chunk(
                     request_id=request_id,
                     model=self.model_uid,
                     request_output=_request_output,
                 )
+
                 for i, choice in enumerate(chunk["choices"]):
                     delta = choice["text"][len(previous_texts[i]) :]
                     previous_texts[i] = choice["text"]
                     choice["text"] = delta
+
+                if tools:
+                    # only handle the first choice
+                    choice = chunk["choices"][0]
+                    if choice["finish_reason"] is not None:
+                        # use previous text for evaluation temporarily
+                        choice_delta = choice["text"]
+                        choice["text"] = previous_texts[0]
+                        _content, func, args = ChatModelMixin._eval_tool_arguments(
+                            self.model_family, chunk, tools
+                        )
+                        choice["text"] = choice_delta
+                        if func is not None:
+                            choice["text"] = None
+                            choice["finish_reason"] = "tool_calls"
+                            choice["tool_calls"] = [
+                                ToolCalls(
+                                    id=str(uuid.uuid4()),
+                                    type="function",
+                                    function=ToolCallFunction(
+                                        name=func,
+                                        arguments=json.dumps(args, ensure_ascii=False),
+                                    ),
+                                )
+                            ]
+                    # use a filter function to skip Qwen's react thought process
+                    elif not tools_token_filter(previous_texts[0]):
+                        continue
                 prompt_tokens = len(_request_output.prompt_token_ids)
                 completion_tokens = sum(
                     len(output.token_ids) for output in _request_output.outputs
@@ -416,7 +464,7 @@ class VLLMChatModel(VLLMModel, ChatModelMixin):
         generate_config = self._sanitize_chat_config(generate_config)
         # TODO(codingl2k1): qwen hacky to set stop for function call.
         model_family = self.model_family.model_family or self.model_family.model_name
-        if tools and "qwen-chat" == model_family:
+        if tools and model_family in ["qwen-chat", "qwen1.5-chat"]:
             stop = generate_config.get("stop")
             if isinstance(stop, str):
                 generate_config["stop"] = [stop, "Observation:"]
@@ -429,7 +477,7 @@ class VLLMChatModel(VLLMModel, ChatModelMixin):
         stream = generate_config.get("stream", None)
 
         if stream:
-            agen = await self.async_generate(full_prompt, generate_config)
+            agen = await self.async_generate(full_prompt, generate_config, tools)
             assert isinstance(agen, AsyncGenerator)
             return self._async_to_chat_completion_chunks(agen)
         else:

xinference/model/rerank/core.py

@@ -42,8 +42,9 @@ def get_rerank_model_descriptions():
 class RerankModelSpec(CacheableModelSpec):
     model_name: str
     language: List[str]
+    type: Optional[str] = "normal"
     model_id: str
-    model_revision: str
+    model_revision: Optional[str]
     model_hub: str = "huggingface"
 
 
@@ -63,6 +64,7 @@ class RerankModelDescription(ModelDescription):
             "model_type": "rerank",
             "address": self.address,
             "accelerators": self.devices,
+            "type": self._model_spec.type,
             "model_name": self._model_spec.model_name,
             "language": self._model_spec.language,
             "model_revision": self._model_spec.model_revision,
@@ -97,12 +99,14 @@ def generate_rerank_description(model_spec: RerankModelSpec) -> Dict[str, List[D
 class RerankModel:
     def __init__(
         self,
+        model_spec: RerankModelSpec,
         model_uid: str,
         model_path: str,
         device: Optional[str] = None,
         use_fp16: bool = False,
         model_config: Optional[Dict] = None,
     ):
+        self._model_spec = model_spec
         self._model_uid = model_uid
         self._model_path = model_path
         self._device = device
@@ -112,20 +116,25 @@ class RerankModel:
 
     def load(self):
         try:
-            from sentence_transformers.cross_encoder import CrossEncoder
+            if self._model_spec.type == "normal":
+                from FlagEmbedding import FlagReranker
+            elif self._model_spec.type == "LLM-based":
+                from FlagEmbedding import FlagLLMReranker as FlagReranker
+            elif self._model_spec.type == "LLM-based layerwise":
+                from FlagEmbedding import LayerWiseFlagLLMReranker as FlagReranker
+            else:
+                raise RuntimeError(
+                    f"Unsupported Rank model type: {self._model_spec.type}"
+                )
         except ImportError:
-            error_message = "Failed to import module 'SentenceTransformer'"
+            error_message = "Failed to import module 'FlagEmbedding'"
             installation_guide = [
-                "Please make sure 'sentence-transformers' is installed. ",
-                "You can install it by `pip install sentence-transformers`\n",
+                "Please make sure 'FlagEmbedding' is installed. ",
+                "You can install it by `pip install FlagEmbedding`\n",
             ]
 
             raise ImportError(f"{error_message}\n\n{''.join(installation_guide)}")
-        self._model = CrossEncoder(
-            self._model_path, device=self._device, **self._model_config
-        )
-        if self._use_fp16:
-            self._model.model.half()
+        self._model = FlagReranker(self._model_path, use_fp16=True)
 
     def rerank(
         self,
@@ -134,12 +143,15 @@ class RerankModel:
         top_n: Optional[int],
         max_chunks_per_doc: Optional[int],
         return_documents: Optional[bool],
+        **kwargs,
     ) -> Rerank:
         assert self._model is not None
+        if kwargs:
+            raise ValueError("rerank hasn't support extra parameter.")
         if max_chunks_per_doc is not None:
             raise ValueError("rerank hasn't support `max_chunks_per_doc` parameter.")
         sentence_combinations = [[query, doc] for doc in documents]
-        similarity_scores = self._model.predict(sentence_combinations)
+        similarity_scores = self._model.compute_score(sentence_combinations)
         sim_scores_argsort = list(reversed(np.argsort(similarity_scores)))
         if top_n is not None:
             sim_scores_argsort = sim_scores_argsort[:top_n]
@@ -221,7 +233,9 @@ def create_rerank_model_instance(
 
     model_path = cache(model_spec)
     use_fp16 = kwargs.pop("use_fp16", False)
-    model = RerankModel(model_uid, model_path, use_fp16=use_fp16, model_config=kwargs)
+    model = RerankModel(
+        model_spec, model_uid, model_path, use_fp16=use_fp16, model_config=kwargs
+    )
     model_description = RerankModelDescription(
         subpool_addr, devices, model_spec, model_path=model_path
     )

xinference/model/rerank/model_spec.json

@@ -1,20 +1,44 @@
 [
   {
     "model_name": "bge-reranker-large",
+    "type": "normal",
     "language": ["en", "zh"],
     "model_id": "BAAI/bge-reranker-large",
     "model_revision": "27c9168d479987529781de8474dff94d69beca11"
   },
   {
     "model_name": "bge-reranker-base",
+    "type": "normal",
     "language": ["en", "zh"],
     "model_id": "BAAI/bge-reranker-base",
     "model_revision": "465b4b7ddf2be0a020c8ad6e525b9bb1dbb708ae"
   },
   {
     "model_name": "bce-reranker-base_v1",
+    "type": "normal",
     "language": ["en", "zh"],
     "model_id": "maidalun1020/bce-reranker-base_v1",
     "model_revision": "eaa31a577a0574e87a08959bd229ca14ce1b5496"
+  },
+  {
+    "model_name": "bge-reranker-v2-m3",
+    "type": "normal",
+    "language": ["en", "zh", "multilingual"],
+    "model_id": "BAAI/bge-reranker-v2-m3",
+    "model_revision": "12e974610ba9083ed95f3edf08d7e899581f4de4"
+  },
+  {
+    "model_name": "bge-reranker-v2-gemma",
+    "type": "LLM-based",
+    "language": ["en", "zh", "multilingual"],
+    "model_id": "BAAI/bge-reranker-v2-gemma",
+    "model_revision": "1787044f8b6fb740a9de4557c3a12377f84d9e17"
+  },
+  {
+    "model_name": "bge-reranker-v2-minicpm-layerwise",
+    "type": "LLM-based layerwise",
+    "language": ["en", "zh", "multilingual"],
+    "model_id": "BAAI/bge-reranker-v2-minicpm-layerwise",
+    "model_revision": "47b5332b296c4d8cb6ee2c60502cc62a0d708881"
   }
 ]

xinference/model/rerank/model_spec_modelscope.json

@@ -1,6 +1,7 @@
 [
   {
     "model_name": "bge-reranker-base",
+    "type": "normal",
     "language": ["en", "zh"],
     "model_id": "Xorbits/bge-reranker-base",
     "model_revision": "v0.0.1",
@@ -8,16 +9,39 @@
   },
   {
     "model_name": "bge-reranker-large",
+    "type": "normal",
     "language": ["en", "zh"],
     "model_id": "Xorbits/bge-reranker-large",
     "model_revision": "v0.0.1",
     "model_hub": "modelscope"
   },
-    {
+  {
     "model_name": "bce-reranker-base_v1",
+    "type": "normal",
     "language": ["en", "zh"],
     "model_id": "maidalun/bce-reranker-base_v1",
     "model_revision": "v0.0.1",
     "model_hub": "modelscope"
+  },
+  {
+    "model_name": "bge-reranker-v2-m3",
+    "type": "normal",
+    "language": ["en", "zh", "multilingual"],
+    "model_id": "AI-ModelScope/bge-reranker-v2-m3",
+    "model_hub": "modelscope"
+  },
+  {
+    "model_name": "bge-reranker-v2-gemma",
+    "type": "LLM-based",
+    "language": ["en", "zh", "multilingual"],
+    "model_id": "AI-ModelScope/bge-reranker-v2-gemma",
+    "model_hub": "modelscope"
+  },
+  {
+    "model_name": "bge-reranker-v2-minicpm-layerwise",
+    "type": "LLM-based layerwise",
+    "language": ["en", "zh", "multilingual"],
+    "model_id": "zfffff/bge-reranker-v2-minicpm-layerwise",
+    "model_hub": "modelscope"
   }
 ]

xinference/model/utils.py

@@ -17,7 +17,7 @@ import os
 import shutil
 from json import JSONDecodeError
 from pathlib import Path
-from typing import Any, Callable, Dict, Optional, Tuple
+from typing import Any, Callable, Dict, Optional, Tuple, Union
 
 from fsspec import AbstractFileSystem
 
@@ -415,3 +415,14 @@ def select_device(device):
             raise ValueError(f"{device} is unavailable in your environment")
 
     return device
+
+
+def convert_float_to_int_or_str(model_size: float) -> Union[int, str]:
+    """convert float to int or string
+
+    if float can be presented as int, convert it to int, otherwise convert it to string
+    """
+    if int(model_size) == model_size:
+        return int(model_size)
+    else:
+        return str(model_size)

xinference/thirdparty/omnilmm/chat.py

@@ -207,7 +207,7 @@ class OmniLMM3B:
 
 class OmniLMMChat:
     def __init__(self, model_path, device_map) -> None:
-        if "12B" in model_path:
+        if "12b" in model_path:
             self.model = OmniLMM12B(model_path, device_map)
         else:
             self.model = OmniLMM3B(model_path, device_map)

xinference/types.py

@@ -91,11 +91,23 @@ class CompletionLogprobs(TypedDict):
     top_logprobs: List[Optional[Dict[str, float]]]
 
 
+class ToolCallFunction(TypedDict):
+    name: str
+    arguments: str
+
+
+class ToolCalls(TypedDict):
+    id: str
+    type: Literal["function"]
+    function: ToolCallFunction
+
+
 class CompletionChoice(TypedDict):
     text: str
     index: int
     logprobs: Optional[CompletionLogprobs]
     finish_reason: Optional[str]
+    tool_calls: NotRequired[List[ToolCalls]]
 
 
 class CompletionUsage(TypedDict):
@@ -147,6 +159,7 @@ class ChatCompletion(TypedDict):
 class ChatCompletionChunkDelta(TypedDict):
     role: NotRequired[str]
     content: NotRequired[str]
+    tool_calls: NotRequired[List[ToolCalls]]
 
 
 class ChatCompletionChunkChoice(TypedDict):
@@ -232,6 +245,8 @@ class LlamaCppModelConfig(TypedDict, total=False):
     n_ctx: int
     n_parts: int
     n_gpu_layers: int
+    split_mode: int
+    main_gpu: int
     seed: int
     f16_kv: bool
     logits_all: bool
@@ -355,21 +370,6 @@ try:
 except ImportError:
     CreateCompletionLlamaCpp = create_model("CreateCompletionLlamaCpp")
 
-CreateCompletionCTransformers: BaseModel
-try:
-    from ctransformers.llm import LLM
-
-    CreateCompletionCTransformers = get_pydantic_model_from_method(
-        LLM.generate,
-        exclude_fields=["tokens"],
-        include_fields={
-            "max_tokens": (Optional[int], max_tokens_field),
-            "stream": (Optional[bool], stream_field),
-        },
-    )
-except ImportError:
-    CreateCompletionCTransformers = create_model("CreateCompletionCTransformers")
-
 
 # This type is for openai API compatibility
 CreateCompletionOpenAI: BaseModel
@@ -415,7 +415,6 @@ class CreateCompletion(
     ModelAndPrompt,
     CreateCompletionTorch,
     CreateCompletionLlamaCpp,
-    CreateCompletionCTransformers,
     CreateCompletionOpenAI,
 ):
     pass
@@ -428,8 +427,6 @@ class CreateChatModel(BaseModel):
 # Currently, chat calls generates, so the params share the same one.
 CreateChatCompletionTorch = CreateCompletionTorch
 CreateChatCompletionLlamaCpp: BaseModel = CreateCompletionLlamaCpp
-CreateChatCompletionCTransformers: BaseModel = CreateCompletionCTransformers
-
 
 # This type is for openai API compatibility
 CreateChatCompletionOpenAI: BaseModel
@@ -450,7 +447,61 @@ class CreateChatCompletion(
     CreateChatModel,
     CreateChatCompletionTorch,
     CreateChatCompletionLlamaCpp,
-    CreateChatCompletionCTransformers,
     CreateChatCompletionOpenAI,
 ):
     pass
+
+
+class LoRA:
+    def __init__(self, lora_name: str, local_path: str):
+        self.lora_name = lora_name
+        self.local_path = local_path
+
+    def to_dict(self):
+        return {
+            "lora_name": self.lora_name,
+            "local_path": self.local_path,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict):
+        return cls(
+            lora_name=data["lora_name"],
+            local_path=data["local_path"],
+        )
+
+
+class PeftModelConfig:
+    def __init__(
+        self,
+        peft_model: Optional[List[LoRA]] = None,
+        image_lora_load_kwargs: Optional[Dict] = None,
+        image_lora_fuse_kwargs: Optional[Dict] = None,
+    ):
+        self.peft_model = peft_model
+        self.image_lora_load_kwargs = image_lora_load_kwargs
+        self.image_lora_fuse_kwargs = image_lora_fuse_kwargs
+
+    def to_dict(self):
+        return {
+            "lora_list": [lora.to_dict() for lora in self.peft_model]
+            if self.peft_model
+            else None,
+            "image_lora_load_kwargs": self.image_lora_load_kwargs,
+            "image_lora_fuse_kwargs": self.image_lora_fuse_kwargs,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict):
+        peft_model_list = data.get("lora_list", None)
+        peft_model = (
+            [LoRA.from_dict(lora_dict) for lora_dict in peft_model_list]
+            if peft_model_list is not None
+            else None
+        )
+
+        return cls(
+            peft_model=peft_model,
+            image_lora_load_kwargs=data.get("image_lora_load_kwargs"),
+            image_lora_fuse_kwargs=data.get("image_lora_fuse_kwargs"),
+        )

xinference/utils.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+
 import torch
 
 

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

@@ -1,11 +1,11 @@
 {
   "files": {
-    "main.js": "./static/js/main.98516614.js",
+    "main.js": "./static/js/main.26fdbfbe.js",
     "static/media/icon.webp": "./static/media/icon.4603d52c63041e5dfbfd.webp",
     "index.html": "./index.html",
-    "main.98516614.js.map": "./static/js/main.98516614.js.map"
+    "main.26fdbfbe.js.map": "./static/js/main.26fdbfbe.js.map"
   },
   "entrypoints": [
-    "static/js/main.98516614.js"
+    "static/js/main.26fdbfbe.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.98516614.js"></script></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.26fdbfbe.js"></script></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>