Add files using upload-large-folder tool

.gitattributes

@@ -27,3 +27,38 @@
 
 # Jupyter notebook
 *.ipynb  text eol=lf
+clip_as_service/docs/hosting/jc-deploy.png filter=lfs diff=lfs merge=lfs -text
+clip_as_service/docs/hosting/colab-banner.png filter=lfs diff=lfs merge=lfs -text
+clip_as_service/docs/_static/banner.png filter=lfs diff=lfs merge=lfs -text
+clip_as_service/docs/_static/colab-banner.png filter=lfs diff=lfs merge=lfs -text
+clip_as_service/docs/_static/favicon.png filter=lfs diff=lfs merge=lfs -text
+clip_as_service/docs/user-guides/images/retreival.png filter=lfs diff=lfs merge=lfs -text
+clip_as_service/docs/user-guides/images/server-start-monitoring.gif filter=lfs diff=lfs merge=lfs -text
+clip_as_service/docs/user-guides/images/memory_usage_dim_512.png filter=lfs diff=lfs merge=lfs -text
+clip_as_service/docs/user-guides/images/client-pgbar.gif filter=lfs diff=lfs merge=lfs -text
+clip_as_service/docs/user-guides/images/server-start.gif filter=lfs diff=lfs merge=lfs -text
+time_r1/trainer/__pycache__/grpo_trainer_env_origin.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+time_r1/trainer/__pycache__/grpo_trainer_env_no_vllm_latest.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+time_r1/trainer/__pycache__/grpo_trainer_env.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+time_r1/trainer/__pycache__/grpo_trainer_env_no_vllm.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+time_r1/trainer/__pycache__/grpo_trainer_env_stage_1.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+time_r1/trainer/__pycache__/grpo_trainer_env_no_vllm_latest_data.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+clip_as_service/docs/user-guides/images/memory_usage_dim_128.png filter=lfs diff=lfs merge=lfs -text
+clip_as_service/docs/user-guides/images/grafana-dashboard.png filter=lfs diff=lfs merge=lfs -text
+clip_as_service/docs/user-guides/images/polling_stratey.png filter=lfs diff=lfs merge=lfs -text
+clip_as_service/tests/img/00001.jpg filter=lfs diff=lfs merge=lfs -text
+clip_as_service/tests/img/00004.jpg filter=lfs diff=lfs merge=lfs -text
+clip_as_service/tests/img/00003.jpg filter=lfs diff=lfs merge=lfs -text
+clip_as_service/tests/img/00002.jpg filter=lfs diff=lfs merge=lfs -text
+clip_as_service/docs/user-guides/images/server-log.gif filter=lfs diff=lfs merge=lfs -text
+clip_as_service/tests/img/00000.jpg filter=lfs diff=lfs merge=lfs -text
+clip_as_service/server/build/lib/clip_server/resources/bpe_simple_vocab_16e6.txt.gz filter=lfs diff=lfs merge=lfs -text
+clip_as_service/server/clip_server/resources/bpe_simple_vocab_16e6.txt.gz filter=lfs diff=lfs merge=lfs -text
+data_prepare/node-v24.12.0-linux-x64.tar.xz filter=lfs diff=lfs merge=lfs -text
+tool_output_reflect.jsonl filter=lfs diff=lfs merge=lfs -text
+assets/grpo_csv.png filter=lfs diff=lfs merge=lfs -text
+siglip-so400m-patch14-384/spiece.model filter=lfs diff=lfs merge=lfs -text
+assets/teaser.png filter=lfs diff=lfs merge=lfs -text
+data_prepare/node-v24.12.0-linux-x64/bin/node filter=lfs diff=lfs merge=lfs -text
+data_prepare/node-v24.12.0-linux-x64/lib/node_modules/npm/node_modules/retry/equation.gif filter=lfs diff=lfs merge=lfs -text
+data_prepare/node-v24.12.0-linux-x64/lib/node_modules/npm/node_modules/qrcode-terminal/example/basic.png filter=lfs diff=lfs merge=lfs -text

clip_as_service/Dockerfiles/base.Dockerfile

@@ -0,0 +1,35 @@
+# !!! An ARG declared before a FROM is outside of a build stage, so it can’t be used in any instruction after a FROM
+ARG JINA_VERSION=3.11.0
+
+FROM jinaai/jina:${JINA_VERSION}-py38-standard
+
+ARG BACKEND_TAG=torch
+
+# constant, wont invalidate cache
+LABEL org.opencontainers.image.vendor="Jina AI Limited" \
+      org.opencontainers.image.licenses="Apache 2.0" \
+      org.opencontainers.image.title="CLIP-as-Service" \
+      org.opencontainers.image.description="Embed images and sentences into fixed-length vectors with CLIP" \
+      org.opencontainers.image.authors="hello@jina.ai" \
+      org.opencontainers.image.url="clip-as-service" \
+      org.opencontainers.image.documentation="https://clip-as-service.jina.ai/"
+
+RUN pip3 install --no-cache-dir torch torchvision torchaudio transformers --extra-index-url https://download.pytorch.org/whl/cpu
+
+# copy will almost always invalid the cache
+COPY . /cas/
+
+WORKDIR /cas
+
+RUN if [ "${BACKEND_TAG}" != "torch" ]; then python3 -m pip install --no-cache-dir "./[${BACKEND_TAG}]" ; fi \
+    && python3 -m pip install --no-cache-dir .
+
+RUN echo "\
+jtype: CLIPEncoder\n\
+metas:\n\
+  py_modules:\n\
+    - clip_server.executors.clip_$BACKEND_TAG\n\
+" > /tmp/config.yml
+
+
+ENTRYPOINT ["jina", "executor", "--uses", "/tmp/config.yml", "--timeout-ready", "3000000"]

clip_as_service/Dockerfiles/cuda.Dockerfile

@@ -0,0 +1,45 @@
+ARG CUDA_VERSION=11.4.2
+
+FROM nvcr.io/nvidia/cuda:${CUDA_VERSION}-cudnn8-runtime-ubuntu20.04
+ENV DEBIAN_FRONTEND=noninteractive
+
+ARG JINA_VERSION=3.11.0
+ARG BACKEND_TAG=torch
+
+# constant, wont invalidate cache
+LABEL org.opencontainers.image.vendor="Jina AI Limited" \
+      org.opencontainers.image.licenses="Apache 2.0" \
+      org.opencontainers.image.title="CLIP-as-Service" \
+      org.opencontainers.image.description="Embed images and sentences into fixed-length vectors with CLIP" \
+      org.opencontainers.image.authors="hello@jina.ai" \
+      org.opencontainers.image.url="clip-as-service" \
+      org.opencontainers.image.documentation="https://clip-as-service.jina.ai/"
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3-setuptools python3-wheel python3-pip \
+    && apt-get clean && rm -rf /var/lib/apt/lists/*;
+
+RUN python3 -m pip install --default-timeout=1000 --no-cache-dir torch torchvision torchaudio nvidia-pyindex transformers --extra-index-url https://download.pytorch.org/whl/cu113
+RUN python3 -m pip install --default-timeout=1000 --no-cache-dir "jina[standard]==${JINA_VERSION}"
+
+# copy will almost always invalid the cache
+COPY . /cas/
+
+WORKDIR /cas
+
+RUN if [ "${BACKEND_TAG}" != "torch" ]; then python3 -m pip install --no-cache-dir "./[${BACKEND_TAG}]" ; fi \
+    && python3 -m pip install --no-cache-dir .
+
+RUN echo "\
+jtype: CLIPEncoder\n\
+metas:\n\
+  py_modules:\n\
+    - clip_server.executors.clip_$BACKEND_TAG\n\
+" > /tmp/config.yml
+
+ENTRYPOINT ["jina", "executor", "--uses", "/tmp/config.yml", "--timeout-ready", "3000000"]
+
+
+
+
+

clip_as_service/Dockerfiles/server.Dockerfile

@@ -0,0 +1,50 @@
+ARG CUDA_VERSION=11.6.0
+
+FROM nvidia/cuda:${CUDA_VERSION}-devel-ubuntu20.04
+
+ARG CAS_NAME=cas
+WORKDIR /${CAS_NAME}
+
+ENV PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1
+
+# constant, wont invalidate cache
+LABEL org.opencontainers.image.vendor="Jina AI Limited" \
+      org.opencontainers.image.licenses="Apache 2.0" \
+      org.opencontainers.image.title="CLIP-as-Service" \
+      org.opencontainers.image.description="Embed images and sentences into fixed-length vectors with CLIP" \
+      org.opencontainers.image.authors="hello@jina.ai" \
+      org.opencontainers.image.url="clip-as-service" \
+      org.opencontainers.image.documentation="https://clip-as-service.jina.ai/"
+
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends python3 python3-pip wget \
+    && ln -sf python3 /usr/bin/python \
+    && ln -sf pip3 /usr/bin/pip \
+    && pip install --upgrade pip \
+    && pip install wheel setuptools nvidia-pyindex \
+    && pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu116
+
+COPY server ./server
+# given by builder
+ARG PIP_TAG
+RUN pip install --default-timeout=1000 --compile ./server/ \
+    && if [ -n "${PIP_TAG}" ]; then pip install --default-timeout=1000 --compile "./server[${PIP_TAG}]" ; fi
+
+ENV LD_LIBRARY_PATH=/usr/local/cuda/lib64
+
+ARG USER_ID=1000
+ARG GROUP_ID=1000
+ARG USER_NAME=${CAS_NAME}
+ARG GROUP_NAME=${CAS_NAME}
+
+RUN groupadd -g ${GROUP_ID} ${USER_NAME} &&\
+    useradd -l -u ${USER_ID} -g ${USER_NAME} ${GROUP_NAME} &&\
+    mkdir /home/${USER_NAME} &&\
+    chown ${USER_NAME}:${GROUP_NAME} /home/${USER_NAME} &&\
+    chown -R ${USER_NAME}:${GROUP_NAME} /${CAS_NAME}/
+
+USER ${USER_NAME}
+
+ENTRYPOINT ["python", "-m", "clip_server"]

clip_as_service/Dockerfiles/tensorrt.Dockerfile

@@ -0,0 +1,38 @@
+# Dockerfile to run Clip-as-Service with TensorRT, CUDA integration
+
+ARG TENSORRT_VERSION=22.04
+
+FROM nvcr.io/nvidia/tensorrt:${TENSORRT_VERSION}-py3
+
+ARG JINA_VERSION=3.7.0
+ARG BACKEND_TAG=tensorrt
+
+# constant, wont invalidate cache
+LABEL org.opencontainers.image.vendor="Jina AI Limited" \
+      org.opencontainers.image.licenses="Apache 2.0" \
+      org.opencontainers.image.title="CLIP-as-Service" \
+      org.opencontainers.image.description="Embed images and sentences into fixed-length vectors with CLIP" \
+      org.opencontainers.image.authors="hello@jina.ai" \
+      org.opencontainers.image.url="clip-as-service" \
+      org.opencontainers.image.documentation="https://clip-as-service.jina.ai/"
+
+RUN pip3 install --default-timeout=1000 --no-cache-dir torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu113
+RUN pip3 -m pip install --default-timeout=1000 --no-cache-dir "jina[standard]==${JINA_VERSION}"
+
+# copy will almost always invalid the cache
+COPY . /cas/
+WORKDIR /cas
+
+RUN python3 -m pip install --no-cache-dir "./[$BACKEND_TAG]"
+
+
+RUN echo "\
+jtype: CLIPEncoder\n\
+metas:\n\
+  py_modules:\n\
+    - clip_server.executors.clip_$BACKEND_TAG\n\
+" > /tmp/config.yml
+
+
+ENTRYPOINT ["jina", "executor", "--uses", "/tmp/config.yml"]
+

clip_as_service/client/clip_client/__init__.py

@@ -0,0 +1,10 @@
+__version__ = '0.8.4'
+
+import os
+
+from clip_client.client import Client
+
+if 'NO_VERSION_CHECK' not in os.environ:
+    from clip_client.helper import is_latest_version
+
+    is_latest_version(github_repo='clip-as-service')

clip_as_service/client/clip_client/client.py

@@ -0,0 +1,890 @@
+import mimetypes
+import os
+import time
+import warnings
+from typing import (
+    overload,
+    TYPE_CHECKING,
+    Optional,
+    Union,
+    Iterator,
+    Generator,
+    Iterable,
+    Dict,
+)
+from urllib.parse import urlparse
+from functools import partial
+from docarray import DocumentArray
+
+if TYPE_CHECKING:
+    import numpy as np
+    from docarray import Document
+    from jina.clients.base import CallbackFnType
+
+
+class Client:
+    def __init__(self, server: str, credential: dict = {}, **kwargs):
+        """Create a Clip client object that connects to the Clip server.
+        Server scheme is in the format of ``scheme://netloc:port``, where
+            - scheme: one of grpc, websocket, http, grpcs, websockets, https
+            - netloc: the server ip address or hostname
+            - port: the public port of the server
+        :param server: the server URI
+        :param credential: the credential for authentication ``{'Authentication': '<token>'}``
+        """
+        try:
+            r = urlparse(server)
+            _port = r.port
+            self._scheme = r.scheme
+        except:
+            raise ValueError(f'{server} is not a valid scheme')
+
+        _tls = False
+        if self._scheme in ('grpcs', 'https', 'wss'):
+            self._scheme = self._scheme[:-1]
+            _tls = True
+
+        if self._scheme == 'ws':
+            self._scheme = 'websocket'  # temp fix for the core
+            if credential:
+                warnings.warn(
+                    'Credential is not supported for websocket, please use grpc or http'
+                )
+
+        if self._scheme in ('grpc', 'http', 'websocket'):
+            _kwargs = dict(host=r.hostname, port=_port, protocol=self._scheme, tls=_tls)
+
+            from jina import Client
+
+            self._client = Client(**_kwargs)
+            self._async_client = Client(**_kwargs, asyncio=True)
+        else:
+            raise ValueError(f'{server} is not a valid scheme')
+
+        self._authorization = credential.get(
+            'Authorization', os.environ.get('CLIP_AUTH_TOKEN')
+        )
+
+    def profile(self, content: Optional[str] = '') -> Dict[str, float]:
+        """Profiling a single query's roundtrip including network and computation latency. Results is summarized in a table.
+        :param content: the content to be sent for profiling. By default it sends an empty Document
+            that helps you understand the network latency.
+        :return: the latency report in a dict.
+        """
+        st = time.perf_counter()
+        r = self._client.post(
+            '/', self._iter_doc([content], DocumentArray()), return_responses=True
+        )
+        ed = (time.perf_counter() - st) * 1000
+        route = r[0].routes
+        gateway_time = (
+            route[0].end_time.ToMilliseconds() - route[0].start_time.ToMilliseconds()
+        )
+        clip_time = (
+            route[1].end_time.ToMilliseconds() - route[1].start_time.ToMilliseconds()
+        )
+        network_time = ed - gateway_time
+        server_network = gateway_time - clip_time
+
+        from rich.table import Table
+
+        def make_table(_title, _time, _percent):
+            table = Table(show_header=False, box=None)
+            table.add_row(
+                _title, f'[b]{_time:.0f}[/b]ms', f'[dim]{_percent * 100:.0f}%[/dim]'
+            )
+            return table
+
+        from rich.tree import Tree
+
+        t = Tree(make_table('Roundtrip', ed, 1))
+        t.add(make_table('Client-server network', network_time, network_time / ed))
+        t2 = t.add(make_table('Server', gateway_time, gateway_time / ed))
+        t2.add(
+            make_table(
+                'Gateway-CLIP network', server_network, server_network / gateway_time
+            )
+        )
+        t2.add(make_table('CLIP model', clip_time, clip_time / gateway_time))
+
+        from rich import print
+
+        print(t)
+
+        return {
+            'Roundtrip': ed,
+            'Client-server network': network_time,
+            'Server': gateway_time,
+            'Gateway-CLIP network': server_network,
+            'CLIP model': clip_time,
+        }
+
+    def _update_pbar(self, response, func: Optional['CallbackFnType'] = None):
+        from rich import filesize
+
+        r = response.data.docs
+        if not self._pbar._tasks[self._r_task].started:
+            self._pbar.start_task(self._r_task)
+        self._pbar.update(
+            self._r_task,
+            advance=len(r),
+            total_size=str(
+                filesize.decimal(int(os.environ.get('JINA_GRPC_RECV_BYTES', '0')))
+            ),
+        )
+        if func is not None:
+            func(response)
+
+    def _prepare_streaming(self, disable, total):
+        if total is None:
+            total = 500
+            warnings.warn(
+                'The length of the input is unknown, the progressbar would not be accurate.'
+            )
+        elif total > 500:
+            warnings.warn(
+                'Please ensure all the inputs are valid, otherwise the request will be aborted.'
+            )
+
+        from docarray.array.mixins.io.pbar import get_pbar
+
+        self._pbar = get_pbar(disable)
+
+        os.environ['JINA_GRPC_SEND_BYTES'] = '0'
+        os.environ['JINA_GRPC_RECV_BYTES'] = '0'
+
+        self._r_task = self._pbar.add_task(
+            ':arrow_down: Progress', total=total, total_size=0, start=False
+        )
+
+    @staticmethod
+    def _gather_result(
+        response, results: 'DocumentArray', attribute: Optional[str] = None
+    ):
+        r = response.data.docs
+        if attribute:
+            results[r[:, 'id']][:, attribute] = r[:, attribute]
+
+    def _iter_doc(
+        self, content, results: Optional['DocumentArray'] = None
+    ) -> Generator['Document', None, None]:
+        from docarray import Document
+
+        for c in content:
+            if isinstance(c, str):
+                _mime = mimetypes.guess_type(c)[0]
+                if _mime and _mime.startswith('image'):
+                    d = Document(
+                        uri=c,
+                    ).load_uri_to_blob()
+                else:
+                    d = Document(text=c)
+            elif isinstance(c, Document):
+                if c.content_type in ('text', 'blob'):
+                    d = c
+                elif not c.blob and c.uri:
+                    c.load_uri_to_blob()
+                    d = c
+                elif c.tensor is not None:
+                    d = c
+                else:
+                    raise TypeError(f'unsupported input type {c!r} {c.content_type}')
+            else:
+                raise TypeError(f'unsupported input type {c!r}')
+
+            if results is not None:
+                results.append(d)
+            yield d
+
+    def _get_post_payload(
+        self, content, results: Optional['DocumentArray'] = None, **kwargs
+    ):
+        payload = dict(
+            inputs=self._iter_doc(content, results),
+            request_size=kwargs.get('batch_size', 8),
+            total_docs=len(content) if hasattr(content, '__len__') else None,
+        )
+
+        if self._scheme == 'grpc' and self._authorization:
+            payload.update(metadata=(('authorization', self._authorization),))
+        elif self._scheme == 'http' and self._authorization:
+            payload.update(headers={'Authorization': self._authorization})
+        return payload
+
+    @staticmethod
+    def _unboxed_result(results: Optional['DocumentArray'] = None, unbox: bool = False):
+        if results is not None:
+            if results.embeddings is None:
+                raise ValueError(
+                    'Empty embedding returned from the server. '
+                    'This often due to a mis-config of the server, '
+                    'restarting the server or changing the serving port number often solves the problem'
+                )
+            return results.embeddings if unbox else results
+
+    @overload
+    def encode(
+        self,
+        content: Iterable[str],
+        *,
+        batch_size: Optional[int] = None,
+        show_progress: bool = False,
+        parameters: Optional[dict] = None,
+        on_done: Optional['CallbackFnType'] = None,
+        on_error: Optional['CallbackFnType'] = None,
+        on_always: Optional['CallbackFnType'] = None,
+        prefetch: int = 100,
+    ) -> 'np.ndarray':
+        """Encode images and texts into embeddings where the input is an iterable of raw strings.
+        Each image and text must be represented as a string. The following strings are acceptable:
+            - local image filepath, will be considered as an image
+            - remote image http/https, will be considered as an image
+            - a dataURI, will be considered as an image
+            - plain text, will be considered as a sentence
+        :param content: an iterator of image URIs or sentences, each element is an image or a text sentence as a string.
+        :param batch_size: the number of elements in each request when sending ``content``
+        :param show_progress: if set, show a progress bar
+        :param parameters: the parameters for the encoding, you can specify the model to use when you have multiple models
+        :param on_done: the callback function executed while streaming, after successful completion of each request.
+            It takes the response ``DataRequest`` as the only argument
+        :param on_error: the callback function executed while streaming, after failed completion of each request.
+            It takes the response ``DataRequest`` as the only argument
+        :param on_always: the callback function executed while streaming, after completion of each request.
+            It takes the response ``DataRequest`` as the only argument
+        :param prefetch: the number of in-flight batches made by the post() method. Use a lower value for expensive
+            operations, and a higher value for faster response times
+        :return: the embedding in a numpy ndarray with shape ``[N, D]``. ``N`` is in the same length of ``content``
+        """
+        ...
+
+    @overload
+    def encode(
+        self,
+        content: Union['DocumentArray', Iterable['Document']],
+        *,
+        batch_size: Optional[int] = None,
+        show_progress: bool = False,
+        parameters: Optional[dict] = None,
+        on_done: Optional['CallbackFnType'] = None,
+        on_error: Optional['CallbackFnType'] = None,
+        on_always: Optional['CallbackFnType'] = None,
+        prefetch: int = 100,
+    ) -> 'DocumentArray':
+        """Encode images and texts into embeddings where the input is an iterable of :class:`docarray.Document`.
+        :param content: an iterable of :class:`docarray.Document`, each Document must be filled with `.uri`, `.text` or `.blob`.
+        :param batch_size: the number of elements in each request when sending ``content``
+        :param show_progress: if set, show a progress bar
+        :param parameters: the parameters for the encoding, you can specify the model to use when you have multiple models
+        :param on_done: the callback function executed while streaming, after successful completion of each request.
+            It takes the response ``DataRequest`` as the only argument
+        :param on_error: the callback function executed while streaming, after failed completion of each request.
+            It takes the response ``DataRequest`` as the only argument
+        :param on_always: the callback function executed while streaming, after completion of each request.
+            It takes the response ``DataRequest`` as the only argument
+        :param prefetch: the number of in-flight batches made by the post() method. Use a lower value for expensive
+            operations, and a higher value for faster response times
+        :return: the embedding in a numpy ndarray with shape ``[N, D]``. ``N`` is in the same length of ``content``
+        """
+        ...
+
+    def encode(self, content, **kwargs):
+        if isinstance(content, str):
+            raise TypeError(
+                f'Content must be an Iterable of [str, Document], try `.encode(["{content}"])` instead'
+            )
+        if hasattr(content, '__len__') and len(content) == 0:
+            return DocumentArray() if isinstance(content, DocumentArray) else []
+
+        self._prepare_streaming(
+            not kwargs.get('show_progress'),
+            total=len(content) if hasattr(content, '__len__') else None,
+        )
+        on_done = kwargs.pop('on_done', None)
+        on_error = kwargs.pop('on_error', None)
+        on_always = kwargs.pop('on_always', None)
+        prefetch = kwargs.pop('prefetch', 100)
+        results = DocumentArray() if not on_done and not on_always else None
+        if not on_done:
+            on_done = partial(
+                self._gather_result, results=results, attribute='embedding'
+            )
+
+        with self._pbar:
+            parameters = kwargs.pop('parameters', {})
+            parameters['drop_image_content'] = parameters.get(
+                'drop_image_content', True
+            )
+            model_name = parameters.pop('model_name', '') if parameters else ''
+
+            self._client.post(
+                on=f'/encode/{model_name}'.rstrip('/'),
+                **self._get_post_payload(content, results, **kwargs),
+                on_done=on_done,
+                on_error=on_error,
+                on_always=partial(self._update_pbar, func=on_always),
+                parameters=parameters,
+                prefetch=prefetch,
+            )
+
+        unbox = hasattr(content, '__len__') and isinstance(content[0], str)
+        return self._unboxed_result(results, unbox)
+
+    @overload
+    async def aencode(
+        self,
+        content: Iterator[str],
+        *,
+        batch_size: Optional[int] = None,
+        show_progress: bool = False,
+        parameters: Optional[dict] = None,
+        on_done: Optional['CallbackFnType'] = None,
+        on_error: Optional['CallbackFnType'] = None,
+        on_always: Optional['CallbackFnType'] = None,
+        prefetch: int = 100,
+    ) -> 'np.ndarray':
+        ...
+
+    @overload
+    async def aencode(
+        self,
+        content: Union['DocumentArray', Iterable['Document']],
+        *,
+        batch_size: Optional[int] = None,
+        show_progress: bool = False,
+        parameters: Optional[dict] = None,
+        on_done: Optional['CallbackFnType'] = None,
+        on_error: Optional['CallbackFnType'] = None,
+        on_always: Optional['CallbackFnType'] = None,
+        prefetch: int = 100,
+    ) -> 'DocumentArray':
+        ...
+
+    async def aencode(self, content, **kwargs):
+        if isinstance(content, str):
+            raise TypeError(
+                f'Content must be an Iterable of [str, Document], try `.aencode(["{content}"])` instead'
+            )
+        if hasattr(content, '__len__') and len(content) == 0:
+            return DocumentArray() if isinstance(content, DocumentArray) else []
+
+        self._prepare_streaming(
+            not kwargs.get('show_progress'),
+            total=len(content) if hasattr(content, '__len__') else None,
+        )
+        on_done = kwargs.pop('on_done', None)
+        on_error = kwargs.pop('on_error', None)
+        on_always = kwargs.pop('on_always', None)
+        prefetch = kwargs.pop('prefetch', 100)
+        results = DocumentArray() if not on_done and not on_always else None
+        if not on_done:
+            on_done = partial(
+                self._gather_result, results=results, attribute='embedding'
+            )
+
+        with self._pbar:
+            parameters = kwargs.pop('parameters', {})
+            parameters['drop_image_content'] = parameters.get(
+                'drop_image_content', True
+            )
+            model_name = parameters.get('model_name', '') if parameters else ''
+
+            async for _ in self._async_client.post(
+                on=f'/encode/{model_name}'.rstrip('/'),
+                **self._get_post_payload(content, results, **kwargs),
+                on_done=on_done,
+                on_error=on_error,
+                on_always=partial(self._update_pbar, func=on_always),
+                parameters=parameters,
+                prefetch=prefetch,
+            ):
+                continue
+
+        unbox = hasattr(content, '__len__') and isinstance(content[0], str)
+        return self._unboxed_result(results, unbox)
+
+    def _iter_rank_docs(
+        self, content, results: Optional['DocumentArray'] = None, source='matches'
+    ) -> Generator['Document', None, None]:
+        from docarray import Document
+
+        for c in content:
+            if isinstance(c, Document):
+                d = self._prepare_rank_doc(c, source)
+            else:
+                raise TypeError(f'Unsupported input type {c!r}')
+            if results is not None:
+                results.append(d)
+            yield d
+
+    def _get_rank_payload(
+        self, content, results: Optional['DocumentArray'] = None, **kwargs
+    ):
+        payload = dict(
+            inputs=self._iter_rank_docs(
+                content, results, source=kwargs.get('source', 'matches')
+            ),
+            request_size=kwargs.get('batch_size', 8),
+            total_docs=len(content) if hasattr(content, '__len__') else None,
+        )
+        if self._scheme == 'grpc' and self._authorization:
+            payload.update(metadata=(('authorization', self._authorization),))
+        elif self._scheme == 'http' and self._authorization:
+            payload.update(headers={'Authorization': self._authorization})
+        return payload
+
+    @staticmethod
+    def _prepare_single_doc(d: 'Document'):
+        if d.content_type in ('text', 'blob'):
+            return d
+        elif not d.blob and d.uri:
+            d.load_uri_to_blob()
+            return d
+        elif d.tensor is not None:
+            return d
+        else:
+            raise TypeError(f'Unsupported input type {d!r} {d.content_type}')
+
+    @staticmethod
+    def _prepare_rank_doc(d: 'Document', _source: str = 'matches'):
+        _get = lambda d: getattr(d, _source)
+        if not _get(d):
+            raise ValueError(f'`.rank()` requires every doc to have `.{_source}`')
+        d = Client._prepare_single_doc(d)
+        setattr(d, _source, [Client._prepare_single_doc(c) for c in _get(d)])
+        return d
+
+    def rank(
+        self, docs: Union['DocumentArray', Iterable['Document']], **kwargs
+    ) -> 'DocumentArray':
+        """Rank image-text matches according to the server CLIP model.
+        Given a Document with nested matches, where the root is image/text and the matches is in another modality, i.e.
+        text/image; this method ranks the matches according to the CLIP model.
+        Each match now has a new score inside ``clip_score`` and matches are sorted descendingly according to this score.
+        More details can be found in: https://github.com/openai/CLIP#usage
+
+        :param docs: the input Documents
+        :return: the ranked Documents in a DocumentArray.
+        """
+        if isinstance(docs, str):
+            raise TypeError(f'Content must be an Iterable of [Document]')
+
+        self._prepare_streaming(
+            not kwargs.get('show_progress'),
+            total=len(docs) if hasattr(docs, '__len__') else None,
+        )
+
+        on_done = kwargs.pop('on_done', None)
+        on_error = kwargs.pop('on_error', None)
+        on_always = kwargs.pop('on_always', None)
+        prefetch = kwargs.pop('prefetch', 100)
+        results = DocumentArray() if not on_done and not on_always else None
+        if not on_done:
+            on_done = partial(self._gather_result, results=results, attribute='matches')
+
+        with self._pbar:
+            parameters = kwargs.pop('parameters', {})
+            parameters['drop_image_content'] = parameters.get(
+                'drop_image_content', True
+            )
+            model_name = parameters.get('model_name', '') if parameters else ''
+
+            self._client.post(
+                on=f'/rank/{model_name}'.rstrip('/'),
+                **self._get_rank_payload(docs, results, **kwargs),
+                on_done=on_done,
+                on_error=on_error,
+                on_always=partial(self._update_pbar, func=on_always),
+                parameters=parameters,
+                prefetch=prefetch,
+            )
+
+        return results
+
+    async def arank(
+        self, docs: Union['DocumentArray', Iterable['Document']], **kwargs
+    ) -> 'DocumentArray':
+        if isinstance(docs, str):
+            raise TypeError(f'Content must be an Iterable of [Document]')
+
+        self._prepare_streaming(
+            not kwargs.get('show_progress'),
+            total=len(docs) if hasattr(docs, '__len__') else None,
+        )
+        on_done = kwargs.pop('on_done', None)
+        on_error = kwargs.pop('on_error', None)
+        on_always = kwargs.pop('on_always', None)
+        prefetch = kwargs.pop('prefetch', 100)
+        results = DocumentArray() if not on_done and not on_always else None
+        if not on_done:
+            on_done = partial(self._gather_result, results=results, attribute='matches')
+
+        with self._pbar:
+            parameters = kwargs.pop('parameters', {})
+            parameters['drop_image_content'] = parameters.get(
+                'drop_image_content', True
+            )
+            model_name = parameters.get('model_name', '') if parameters else ''
+
+            async for _ in self._async_client.post(
+                on=f'/rank/{model_name}'.rstrip('/'),
+                **self._get_rank_payload(docs, results, **kwargs),
+                on_done=on_done,
+                on_error=on_error,
+                on_always=partial(self._update_pbar, func=on_always),
+                parameters=parameters,
+                prefetch=prefetch,
+            ):
+                continue
+
+        return results
+
+    @overload
+    def index(
+        self,
+        content: Iterable[str],
+        *,
+        batch_size: Optional[int] = None,
+        show_progress: bool = False,
+        parameters: Optional[Dict] = None,
+        on_done: Optional['CallbackFnType'] = None,
+        on_error: Optional['CallbackFnType'] = None,
+        on_always: Optional['CallbackFnType'] = None,
+        prefetch: int = 100,
+    ):
+        """Index the images or texts where their embeddings are computed by the server CLIP model.
+
+        Each image and text must be represented as a string. The following strings are acceptable:
+            - local image filepath, will be considered as an image
+            - remote image http/https, will be considered as an image
+            - a dataURI, will be considered as an image
+            - plain text, will be considered as a sentence
+        :param content: an iterator of image URIs or sentences, each element is an image or a text sentence as a string.
+        :param batch_size: the number of elements in each request when sending ``content``
+        :param show_progress: if set, show a progress bar
+        :param parameters: the parameters for the indexing, you can specify the model to use when you have multiple models
+        :param on_done: the callback function executed while streaming, after successful completion of each request.
+            It takes the response ``DataRequest`` as the only argument
+        :param on_error: the callback function executed while streaming, after an error occurs in each request.
+            It takes the response ``DataRequest`` as the only argument
+        :param on_always: the callback function executed while streaming, after each request is completed.
+            It takes the response ``DataRequest`` as the only argument
+        :param prefetch: the number of in-flight batches made by the post() method. Use a lower value for expensive
+            operations, and a higher value for faster response times
+        :return: the embedding in a numpy ndarray with shape ``[N, D]``. ``N`` is in the same length of ``content``
+        """
+        ...
+
+    @overload
+    def index(
+        self,
+        content: Union['DocumentArray', Iterable['Document']],
+        *,
+        batch_size: Optional[int] = None,
+        show_progress: bool = False,
+        parameters: Optional[dict] = None,
+        on_done: Optional['CallbackFnType'] = None,
+        on_error: Optional['CallbackFnType'] = None,
+        on_always: Optional['CallbackFnType'] = None,
+        prefetch: int = 100,
+    ) -> 'DocumentArray':
+        """Index the images or texts where their embeddings are computed by the server CLIP model.
+
+        :param content: an iterable of :class:`docarray.Document`, each Document must be filled with `.uri`, `.text` or `.blob`.
+        :param batch_size: the number of elements in each request when sending ``content``
+        :param show_progress: if set, show a progress bar
+        :param parameters: the parameters for the indexing, you can specify the model to use when you have multiple models
+        :param on_done: the callback function executed while streaming, after successful completion of each request.
+            It takes the response ``DataRequest`` as the only argument
+        :param on_error: the callback function executed while streaming, after an error occurs in each request.
+            It takes the response ``DataRequest`` as the only argument
+        :param on_always: the callback function executed while streaming, after each request is completed.
+            It takes the response ``DataRequest`` as the only argument
+        :param prefetch: the number of in-flight batches made by the post() method. Use a lower value for expensive
+            operations, and a higher value for faster response times
+        :return: the embedding in a numpy ndarray with shape ``[N, D]``. ``N`` is in the same length of ``content``
+        """
+        ...
+
+    def index(self, content, **kwargs):
+        if isinstance(content, str):
+            raise TypeError(
+                f'content must be an Iterable of [str, Document], try `.index(["{content}"])` instead'
+            )
+
+        self._prepare_streaming(
+            not kwargs.get('show_progress'),
+            total=len(content) if hasattr(content, '__len__') else None,
+        )
+        on_done = kwargs.pop('on_done', None)
+        on_error = kwargs.pop('on_error', None)
+        on_always = kwargs.pop('on_always', None)
+        prefetch = kwargs.pop('prefetch', 100)
+        results = DocumentArray() if not on_done and not on_always else None
+        if not on_done:
+            on_done = partial(
+                self._gather_result, results=results, attribute='embedding'
+            )
+
+        with self._pbar:
+            parameters = kwargs.pop('parameters', {})
+            parameters['drop_image_content'] = parameters.get(
+                'drop_image_content', True
+            )
+
+            self._client.post(
+                on='/index',
+                **self._get_post_payload(content, results, **kwargs),
+                on_done=on_done,
+                on_error=on_error,
+                on_always=partial(self._update_pbar, func=on_always),
+                parameters=parameters,
+                prefetch=prefetch,
+            )
+
+        return results
+
+    @overload
+    async def aindex(
+        self,
+        content: Iterator[str],
+        *,
+        batch_size: Optional[int] = None,
+        show_progress: bool = False,
+        parameters: Optional[Dict] = None,
+        on_done: Optional['CallbackFnType'] = None,
+        on_error: Optional['CallbackFnType'] = None,
+        on_always: Optional['CallbackFnType'] = None,
+        prefetch: int = 100,
+    ):
+        ...
+
+    @overload
+    async def aindex(
+        self,
+        content: Union['DocumentArray', Iterable['Document']],
+        *,
+        batch_size: Optional[int] = None,
+        show_progress: bool = False,
+        parameters: Optional[dict] = None,
+        on_done: Optional['CallbackFnType'] = None,
+        on_error: Optional['CallbackFnType'] = None,
+        on_always: Optional['CallbackFnType'] = None,
+        prefetch: int = 100,
+    ):
+        ...
+
+    async def aindex(self, content, **kwargs):
+        if isinstance(content, str):
+            raise TypeError(
+                f'content must be an Iterable of [str, Document], try `.aindex(["{content}"])` instead'
+            )
+
+        self._prepare_streaming(
+            not kwargs.get('show_progress'),
+            total=len(content) if hasattr(content, '__len__') else None,
+        )
+        on_done = kwargs.pop('on_done', None)
+        on_error = kwargs.pop('on_error', None)
+        on_always = kwargs.pop('on_always', None)
+        prefetch = kwargs.pop('prefetch', 100)
+        results = DocumentArray() if not on_done and not on_always else None
+        if not on_done:
+            on_done = partial(
+                self._gather_result, results=results, attribute='embedding'
+            )
+
+        with self._pbar:
+            parameters = kwargs.pop('parameters', {})
+            parameters['drop_image_content'] = parameters.get(
+                'drop_image_content', True
+            )
+
+            async for _ in self._async_client.post(
+                on='/index',
+                **self._get_post_payload(content, results, **kwargs),
+                on_done=on_done,
+                on_error=on_error,
+                on_always=partial(self._update_pbar, func=on_always),
+                parameters=parameters,
+                prefetch=prefetch,
+            ):
+                continue
+
+        return results
+
+    @overload
+    def search(
+        self,
+        content: Iterable[str],
+        *,
+        limit: int = 10,
+        batch_size: Optional[int] = None,
+        show_progress: bool = False,
+        parameters: Optional[Dict] = None,
+        on_done: Optional['CallbackFnType'] = None,
+        on_error: Optional['CallbackFnType'] = None,
+        on_always: Optional['CallbackFnType'] = None,
+        prefetch: int = 100,
+    ) -> 'DocumentArray':
+        """Search for top k results for given query string or ``Document``.
+
+        If the input is a string, will use this string as query. If the input is a ``Document``,
+        will use this ``Document`` as query.
+
+        :param content: list of queries.
+        :param limit: the number of results to return.
+        :param batch_size: the number of elements in each request when sending ``content``.
+        :param show_progress: if set, show a progress bar.
+        :param parameters: parameters passed to search function.
+        :param on_done: the callback function executed while streaming, after successful completion of each request.
+            It takes the response ``DataRequest`` as the only argument
+        :param on_error: the callback function executed while streaming, after an error occurs in each request.
+            It takes the response ``DataRequest`` as the only argument
+        :param on_always: the callback function executed while streaming, after each request is completed.
+            It takes the response ``DataRequest`` as the only argument
+        :param prefetch: the number of in-flight batches made by the post() method. Use a lower value for expensive
+            operations, and a higher value for faster response times
+        """
+        ...
+
+    @overload
+    def search(
+        self,
+        content: Union['DocumentArray', Iterable['Document']],
+        *,
+        limit: int = 10,
+        batch_size: Optional[int] = None,
+        show_progress: bool = False,
+        parameters: Optional[dict] = None,
+        on_done: Optional['CallbackFnType'] = None,
+        on_error: Optional['CallbackFnType'] = None,
+        on_always: Optional['CallbackFnType'] = None,
+        prefetch: int = 100,
+    ) -> 'DocumentArray':
+        """Search for top k results for given query string or ``Document``.
+
+        If the input is a string, will use this string as query. If the input is a ``Document``,
+        will use this ``Document`` as query.
+
+        :param content: list of queries.
+        :param limit: the number of results to return.
+        :param batch_size: the number of elements in each request when sending ``content``.
+        :param show_progress: if set, show a progress bar.
+        :param parameters: parameters passed to search function.
+        :param on_done: the callback function executed while streaming, after successful completion of each request.
+            It takes the response ``DataRequest`` as the only argument
+        :param on_error: the callback function executed while streaming, after an error occurs in each request.
+            It takes the response ``DataRequest`` as the only argument
+        :param on_always: the callback function executed while streaming, after each request is completed.
+            It takes the response ``DataRequest`` as the only argument
+        :param prefetch: the number of in-flight batches made by the post() method. Use a lower value for expensive
+            operations, and a higher value for faster response times
+        """
+        ...
+
+    def search(self, content, limit: int = 10, **kwargs) -> 'DocumentArray':
+        if isinstance(content, str):
+            raise TypeError(
+                f'content must be an Iterable of [str, Document], try `.search(["{content}"])` instead'
+            )
+
+        self._prepare_streaming(
+            not kwargs.get('show_progress'),
+            total=len(content) if hasattr(content, '__len__') else None,
+        )
+        on_done = kwargs.pop('on_done', None)
+        on_error = kwargs.pop('on_error', None)
+        on_always = kwargs.pop('on_always', None)
+        prefetch = kwargs.pop('prefetch', 100)
+        results = DocumentArray() if not on_done and not on_always else None
+        if not on_done:
+            on_done = partial(self._gather_result, results=results, attribute='matches')
+
+        with self._pbar:
+            parameters = kwargs.pop('parameters', {})
+            parameters['limit'] = limit
+            parameters['drop_image_content'] = parameters.get(
+                'drop_image_content', True
+            )
+
+            self._client.post(
+                on='/search',
+                **self._get_post_payload(content, results, **kwargs),
+                on_done=on_done,
+                on_error=on_error,
+                on_always=partial(self._update_pbar, func=on_always),
+                parameters=parameters,
+                prefetch=prefetch,
+            )
+
+        return results
+
+    @overload
+    async def asearch(
+        self,
+        content: Iterator[str],
+        *,
+        limit: int = 10,
+        batch_size: Optional[int] = None,
+        show_progress: bool = False,
+        parameters: Optional[Dict] = None,
+        on_done: Optional['CallbackFnType'] = None,
+        on_error: Optional['CallbackFnType'] = None,
+        on_always: Optional['CallbackFnType'] = None,
+        prefetch: int = 100,
+    ):
+        ...
+
+    @overload
+    async def asearch(
+        self,
+        content: Union['DocumentArray', Iterable['Document']],
+        *,
+        limit: int = 10,
+        batch_size: Optional[int] = None,
+        show_progress: bool = False,
+        parameters: Optional[dict] = None,
+        on_done: Optional['CallbackFnType'] = None,
+        on_error: Optional['CallbackFnType'] = None,
+        on_always: Optional['CallbackFnType'] = None,
+        prefetch: int = 100,
+    ):
+        ...
+
+    async def asearch(self, content, limit: int = 10, **kwargs):
+        if isinstance(content, str):
+            raise TypeError(
+                f'content must be an Iterable of [str, Document], try `.asearch(["{content}"])` instead'
+            )
+
+        self._prepare_streaming(
+            not kwargs.get('show_progress'),
+            total=len(content) if hasattr(content, '__len__') else None,
+        )
+        on_done = kwargs.pop('on_done', None)
+        on_error = kwargs.pop('on_error', None)
+        on_always = kwargs.pop('on_always', None)
+        prefetch = kwargs.pop('prefetch', 100)
+        results = DocumentArray() if not on_done and not on_always else None
+        if not on_done:
+            on_done = partial(self._gather_result, results=results, attribute='matches')
+
+        with self._pbar:
+            parameters = kwargs.pop('parameters', {})
+            parameters['limit'] = limit
+            parameters['drop_image_content'] = parameters.get(
+                'drop_image_content', True
+            )
+
+            async for _ in self._async_client.post(
+                on='/search',
+                **self._get_post_payload(content, results, **kwargs),
+                on_done=on_done,
+                on_error=on_error,
+                on_always=partial(self._update_pbar, func=on_always),
+                parameters=parameters,
+                prefetch=prefetch,
+            ):
+                continue
+
+        return results

clip_as_service/client/clip_client/helper.py

@@ -0,0 +1,54 @@
+import json
+import sys
+import threading
+from packaging.version import Version
+from urllib.request import Request, urlopen
+
+import pkg_resources
+from rich import print
+from rich.panel import Panel
+
+
+def _version_check(package: str = None, github_repo: str = None):
+    try:
+
+        if not package:
+            package = vars(sys.modules[__name__])['__package__']
+        if not github_repo:
+            github_repo = package
+
+        cur_ver = Version(pkg_resources.get_distribution(package).version)
+        req = Request(
+            f'https://pypi.python.org/pypi/{package}/json',
+            headers={'User-Agent': 'Mozilla/5.0'},
+        )
+        with urlopen(
+            req, timeout=1
+        ) as resp:  # 'with' is important to close the resource after use
+            j = json.load(resp)
+            releases = j.get('releases', {})
+            latest_release_ver = max(
+                Version(v) for v in releases.keys() if '.dev' not in v
+            )
+            if cur_ver < latest_release_ver:
+                print(
+                    Panel(
+                        f'You are using [b]{package} {cur_ver}[/b], but [bold green]{latest_release_ver}[/] is available. '
+                        f'You may upgrade it via [b]pip install -U {package}[/b]. [link=https://github.com/jina-ai/{github_repo}/releases]Read Changelog here[/link].',
+                        title=':new: New version available!',
+                        width=50,
+                    )
+                )
+    except Exception:
+        # no network, too slow, PyPi is down
+        pass
+
+
+def is_latest_version(package: str = None, github_repo: str = None) -> None:
+    """Check if there is a latest version from Pypi, set env `NO_VERSION_CHECK` to disable it.
+
+    :param package: package name if none auto-detected
+    :param github_repo: repo name that contains CHANGELOG if none then the same as package name
+    """
+
+    threading.Thread(target=_version_check, args=(package, github_repo)).start()

clip_as_service/client/setup.py

@@ -0,0 +1,93 @@
+import sys
+from os import path
+
+from setuptools import find_packages
+from setuptools import setup
+
+if sys.version_info < (3, 7, 0):
+    raise OSError(f'CLIP-as-service requires Python >=3.7, but yours is {sys.version}')
+
+try:
+    pkg_name = 'clip-client'
+    libinfo_py = path.join(
+        path.dirname(__file__), pkg_name.replace('-', '_'), '__init__.py'
+    )
+    libinfo_content = open(libinfo_py, 'r', encoding='utf8').readlines()
+    version_line = [l.strip() for l in libinfo_content if l.startswith('__version__')][
+        0
+    ]
+    exec(version_line)  # gives __version__
+except FileNotFoundError as ex:
+    __version__ = '0.0.0'
+
+try:
+    with open('../README.md', encoding='utf8') as fp:
+        _long_description = fp.read()
+except FileNotFoundError:
+    _long_description = ''
+
+setup(
+    name=pkg_name,
+    packages=find_packages(),
+    version=__version__,
+    include_package_data=True,
+    description='Embed images and sentences into fixed-length vectors via CLIP',
+    author='Jina AI',
+    author_email='hello@jina.ai',
+    license='Apache 2.0',
+    url='https://github.com/jina-ai/clip-as-service',
+    download_url='https://github.com/jina-ai/clip-as-service/tags',
+    long_description=_long_description,
+    long_description_content_type='text/markdown',
+    zip_safe=False,
+    setup_requires=['setuptools>=18.0', 'wheel'],
+    install_requires=[
+        'jina>=3.12.0',
+        'docarray[common]>=0.19.0,<0.30.0',
+        'packaging',
+    ],
+    extras_require={
+        'test': [
+            'pytest',
+            'pytest-timeout',
+            'pytest-mock',
+            'pytest-asyncio',
+            'pytest-cov',
+            'pytest-repeat',
+            'pytest-reraise',
+            'mock',
+            'pytest-custom_exit_code',
+            'black',
+        ],
+    },
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+        'Intended Audience :: Developers',
+        'Intended Audience :: Education',
+        'Intended Audience :: Science/Research',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Unix Shell',
+        'Environment :: Console',
+        'License :: OSI Approved :: Apache Software License',
+        'Operating System :: OS Independent',
+        'Topic :: Database :: Database Engines/Servers',
+        'Topic :: Scientific/Engineering :: Artificial Intelligence',
+        'Topic :: Internet :: WWW/HTTP :: Indexing/Search',
+        'Topic :: Scientific/Engineering :: Image Recognition',
+        'Topic :: Multimedia :: Video',
+        'Topic :: Scientific/Engineering',
+        'Topic :: Scientific/Engineering :: Mathematics',
+        'Topic :: Software Development',
+        'Topic :: Software Development :: Libraries',
+        'Topic :: Software Development :: Libraries :: Python Modules',
+    ],
+    project_urls={
+        'Documentation': 'https://clip-as-service.jina.ai',
+        'Source': 'https://github.com/jina-ai/clip-as-service/',
+        'Tracker': 'https://github.com/jina-ai/clip-as-service/issues',
+    },
+    keywords='jina openai clip deep-learning cross-modal multi-modal neural-search',
+)

clip_as_service/docs/Makefile

@@ -0,0 +1,19 @@
+# Minimal makefile for Sphinx documentation
+# Used only for local building
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

clip_as_service/docs/_static/cas-grafana.json

@@ -0,0 +1,900 @@
+{
+  "__inputs": [
+    {
+      "name": "DS_PROMETHEUS",
+      "label": "Prometheus",
+      "description": "",
+      "type": "datasource",
+      "pluginId": "prometheus",
+      "pluginName": "Prometheus"
+    }
+  ],
+  "__elements": [],
+  "__requires": [
+    {
+      "type": "grafana",
+      "id": "grafana",
+      "name": "Grafana",
+      "version": "8.5.3"
+    },
+    {
+      "type": "panel",
+      "id": "piechart",
+      "name": "Pie chart",
+      "version": ""
+    },
+    {
+      "type": "datasource",
+      "id": "prometheus",
+      "name": "Prometheus",
+      "version": "1.0.0"
+    },
+    {
+      "type": "panel",
+      "id": "stat",
+      "name": "Stat",
+      "version": ""
+    },
+    {
+      "type": "panel",
+      "id": "timeseries",
+      "name": "Time series",
+      "version": ""
+    }
+  ],
+  "annotations": {
+    "list": [
+      {
+        "builtIn": 1,
+        "datasource": {
+          "type": "datasource",
+          "uid": "grafana"
+        },
+        "enable": true,
+        "hide": true,
+        "iconColor": "rgba(0, 211, 255, 1)",
+        "name": "Annotations & Alerts",
+        "target": {
+          "limit": 100,
+          "matchAny": false,
+          "tags": [],
+          "type": "dashboard"
+        },
+        "type": "dashboard"
+      }
+    ]
+  },
+  "description": "The datashboard for CLIP-as-service",
+  "editable": true,
+  "fiscalYearStartMonth": 0,
+  "graphTooltip": 0,
+  "id": null,
+  "iteration": 1654148217937,
+  "links": [],
+  "liveNow": false,
+  "panels": [
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_PROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            }
+          },
+          "mappings": [],
+          "unit": "s"
+        },
+        "overrides": [
+          {
+            "__systemRef": "hideSeriesFrom",
+            "matcher": {
+              "id": "byNames",
+              "options": {
+                "mode": "exclude",
+                "names": [
+                  "gateway overhead",
+                  "gateway/worker network",
+                  "processing-",
+                  "preproc text"
+                ],
+                "prefix": "All except:",
+                "readOnly": true
+              }
+            },
+            "properties": [
+              {
+                "id": "custom.hideFrom",
+                "value": {
+                  "legend": false,
+                  "tooltip": false,
+                  "viz": true
+                }
+              }
+            ]
+          }
+        ]
+      },
+      "gridPos": {
+        "h": 16,
+        "w": 13,
+        "x": 0,
+        "y": 0
+      },
+      "id": 41,
+      "options": {
+        "displayLabels": [
+          "name"
+        ],
+        "legend": {
+          "displayMode": "table",
+          "placement": "right",
+          "values": [
+            "value",
+            "percent"
+          ]
+        },
+        "pieType": "pie",
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ],
+          "fields": "",
+          "values": false
+        },
+        "tooltip": {
+          "mode": "single",
+          "sort": "none"
+        }
+      },
+      "pluginVersion": "8.4.4",
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_PROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "jina_receiving_request_seconds_sum / jina_receiving_request_seconds_count",
+          "hide": false,
+          "interval": "",
+          "legendFormat": "receiving-{{job}}",
+          "refId": "A"
+        },
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_PROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "jina_sending_request_seconds_sum / jina_sending_request_seconds_count",
+          "hide": false,
+          "interval": "",
+          "legendFormat": "sending-{{job}}",
+          "refId": "D"
+        },
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_PROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "jina_preprocess_texts_seconds_sum / jina_preprocess_texts_seconds_count",
+          "hide": false,
+          "interval": "",
+          "legendFormat": "preproc text",
+          "refId": "B"
+        },
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_PROMETHEUS}"
+          },
+          "editorMode": "code",
+          "exemplar": true,
+          "expr": "jina_encode_texts_seconds_sum / jina_encode_texts_seconds_count",
+          "hide": false,
+          "interval": "",
+          "legendFormat": "encode text",
+          "range": true,
+          "refId": "C"
+        },
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_PROMETHEUS}"
+          },
+          "editorMode": "code",
+          "exemplar": true,
+          "expr": "jina_process_request_seconds_sum / jina_process_request_seconds_count",
+          "hide": false,
+          "interval": "",
+          "legendFormat": "processing-encode",
+          "range": true,
+          "refId": "E"
+        },
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_PROMETHEUS}"
+          },
+          "editorMode": "code",
+          "expr": "jina_preprocess_images_seconds_sum / jina_preprocess_images_seconds_count",
+          "hide": false,
+          "legendFormat": "preproc image",
+          "range": true,
+          "refId": "F"
+        },
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_PROMETHEUS}"
+          },
+          "editorMode": "code",
+          "expr": "jina_encode_images_seconds_sum / jina_encode_images_seconds_count",
+          "hide": false,
+          "legendFormat": "encode image",
+          "range": true,
+          "refId": "G"
+        }
+      ],
+      "title": "life cycle of a request",
+      "transformations": [
+        {
+          "id": "calculateField",
+          "options": {
+            "alias": "gateway overhead",
+            "binary": {
+              "left": "receiving-gateway",
+              "operator": "-",
+              "reducer": "sum",
+              "right": "sending-gateway"
+            },
+            "mode": "binary",
+            "reduce": {
+              "reducer": "sum"
+            }
+          }
+        },
+        {
+          "id": "calculateField",
+          "options": {
+            "alias": "worker-overhead",
+            "binary": {
+              "left": "receiving-exec",
+              "operator": "-",
+              "reducer": "sum",
+              "right": "processing-encode"
+            },
+            "mode": "binary",
+            "reduce": {
+              "reducer": "sum"
+            }
+          }
+        },
+        {
+          "id": "calculateField",
+          "options": {
+            "alias": "text-model-inference",
+            "binary": {
+              "left": "processing-encode",
+              "operator": "-",
+              "reducer": "sum",
+              "right": "preproc text"
+            },
+            "mode": "binary",
+            "reduce": {
+              "reducer": "sum"
+            }
+          }
+        },
+        {
+          "id": "calculateField",
+          "options": {
+            "alias": "gateway/worker network",
+            "binary": {
+              "left": "sending-gateway",
+              "operator": "-",
+              "reducer": "sum",
+              "right": "receiving-exec"
+            },
+            "mode": "binary",
+            "reduce": {
+              "reducer": "sum"
+            }
+          }
+        },
+        {
+          "id": "calculateField",
+          "options": {
+            "alias": "visual-model-inference",
+            "binary": {
+              "left": "processing-encode",
+              "reducer": "sum",
+              "right": "preproc image"
+            },
+            "mode": "binary",
+            "reduce": {
+              "reducer": "sum"
+            }
+          }
+        }
+      ],
+      "type": "piechart"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_PROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "thresholds"
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 6,
+        "x": 15,
+        "y": 0
+      },
+      "id": 32,
+      "options": {
+        "colorMode": "value",
+        "graphMode": "area",
+        "justifyMode": "auto",
+        "orientation": "auto",
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ],
+          "fields": "",
+          "values": false
+        },
+        "textMode": "auto"
+      },
+      "pluginVersion": "8.5.3",
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_PROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "jina_receiving_request_seconds_count{runtime_name=~\"gateway.*\"}",
+          "instant": false,
+          "interval": "",
+          "intervalFactor": 1,
+          "legendFormat": "",
+          "refId": "A"
+        }
+      ],
+      "title": "Number of Request processed ",
+      "type": "stat"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_PROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 0,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          },
+          "unit": "s"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 15,
+        "x": 0,
+        "y": 16
+      },
+      "id": 39,
+      "options": {
+        "legend": {
+          "calcs": [],
+          "displayMode": "list",
+          "placement": "bottom"
+        },
+        "tooltip": {
+          "mode": "single",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_PROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "jina_receiving_request_seconds_sum / jina_receiving_request_seconds_count",
+          "interval": "",
+          "legendFormat": "{{runtime_name}}",
+          "refId": "A"
+        }
+      ],
+      "title": "jina_receiving_request_seconds_sum",
+      "type": "timeseries"
+    },
+    {
+      "collapsed": false,
+      "datasource": {
+        "type": "prometheus",
+        "uid": "PBFA97CFB590B2093"
+      },
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 24
+      },
+      "id": 4,
+      "panels": [],
+      "repeat": "Executor",
+      "title": "$Executor",
+      "type": "row"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_PROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "thresholds"
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green"
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 5,
+        "w": 8,
+        "x": 0,
+        "y": 25
+      },
+      "id": 2,
+      "options": {
+        "colorMode": "value",
+        "graphMode": "area",
+        "justifyMode": "auto",
+        "orientation": "auto",
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ],
+          "fields": "",
+          "values": false
+        },
+        "textMode": "auto"
+      },
+      "pluginVersion": "8.5.3",
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_PROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "jina_document_processed_total{runtime_name=\"$Executor\"}",
+          "instant": false,
+          "interval": "",
+          "intervalFactor": 1,
+          "legendFormat": "{{executor_endpoint}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Number of Documents processed per endpoint",
+      "type": "stat"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_PROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "thresholds"
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green"
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 5,
+        "w": 8,
+        "x": 8,
+        "y": 25
+      },
+      "id": 7,
+      "options": {
+        "colorMode": "value",
+        "graphMode": "area",
+        "justifyMode": "auto",
+        "orientation": "auto",
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ],
+          "fields": "",
+          "values": false
+        },
+        "textMode": "auto"
+      },
+      "pluginVersion": "8.5.3",
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_PROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "jina_process_request_seconds_count{runtime_name=\"$Executor\"}",
+          "instant": false,
+          "interval": "",
+          "intervalFactor": 1,
+          "legendFormat": "{{executor_endpoint}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Number of requests per endpoint",
+      "type": "stat"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_PROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 0,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green"
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          },
+          "unit": "s"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 6,
+        "w": 18,
+        "x": 0,
+        "y": 30
+      },
+      "id": 12,
+      "options": {
+        "legend": {
+          "calcs": [],
+          "displayMode": "list",
+          "placement": "bottom"
+        },
+        "tooltip": {
+          "mode": "single",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_PROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "jina_process_request_seconds_sum{runtime_name=\"$Executor\"} / jina_process_request_seconds_count{runtime_name=\"$Executor\"}",
+          "interval": "",
+          "legendFormat": "{{executor_endpoint}}-process",
+          "refId": "A"
+        }
+      ],
+      "title": "Time spend calling the Executor method link the to endpoint",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_PROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 0,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green"
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          },
+          "unit": "s"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 6,
+        "w": 18,
+        "x": 0,
+        "y": 36
+      },
+      "id": 17,
+      "options": {
+        "legend": {
+          "calcs": [],
+          "displayMode": "list",
+          "placement": "bottom"
+        },
+        "tooltip": {
+          "mode": "single",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_PROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "jina_receiving_request_seconds_sum{runtime_name=\"$Executor\"} / jina_receiving_request_seconds_count{runtime_name=\"$Executor\"}",
+          "interval": "",
+          "legendFormat": "{{executor_endpoint}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Time spend calling between receiving and responding ",
+      "type": "timeseries"
+    }
+  ],
+  "refresh": "",
+  "schemaVersion": 36,
+  "style": "dark",
+  "tags": [
+    "clip",
+    "jina"
+  ],
+  "templating": {
+    "list": [
+      {
+        "current": {},
+        "datasource": {
+          "type": "prometheus",
+          "uid": "${DS_PROMETHEUS}"
+        },
+        "definition": "label_values(jina_document_processed_created,executor_endpoint)\n",
+        "description": "",
+        "hide": 0,
+        "includeAll": true,
+        "multi": true,
+        "name": "Endpoint",
+        "options": [],
+        "query": {
+          "query": "label_values(jina_document_processed_created,executor_endpoint)\n",
+          "refId": "StandardVariableQuery"
+        },
+        "refresh": 1,
+        "regex": "",
+        "skipUrlSync": false,
+        "sort": 0,
+        "type": "query"
+      },
+      {
+        "current": {},
+        "datasource": {
+          "type": "prometheus",
+          "uid": "${DS_PROMETHEUS}"
+        },
+        "definition": "label_values(jina_document_processed_created,runtime_name)\n",
+        "description": "",
+        "hide": 0,
+        "includeAll": true,
+        "multi": true,
+        "name": "Executor",
+        "options": [],
+        "query": {
+          "query": "label_values(jina_document_processed_created,runtime_name)\n",
+          "refId": "StandardVariableQuery"
+        },
+        "refresh": 1,
+        "regex": "",
+        "skipUrlSync": false,
+        "sort": 0,
+        "type": "query"
+      },
+      {
+        "current": {
+          "selected": false,
+          "text": "Prometheus",
+          "value": "Prometheus"
+        },
+        "hide": 0,
+        "includeAll": false,
+        "multi": false,
+        "name": "datasource",
+        "options": [],
+        "query": "prometheus",
+        "queryValue": "",
+        "refresh": 1,
+        "regex": "",
+        "skipUrlSync": false,
+        "type": "datasource"
+      }
+    ]
+  },
+  "time": {
+    "from": "now-5m",
+    "to": "now"
+  },
+  "timepicker": {},
+  "timezone": "",
+  "title": "clip-as-service",
+  "uid": "e_4RtOlnz",
+  "version": 3,
+  "weekStart": ""
+}

clip_as_service/docs/_static/demo-embed.html

@@ -0,0 +1,213 @@
+<script src="https://cdn.jsdelivr.net/npm/vue@2/dist/vue.js"></script>
+<script src='https://cdnjs.cloudflare.com/ajax/libs/jquery/2.1.3/jquery.min.js'></script>
+
+<div id="demo-embed">
+
+
+    <table class="embeddingInput">
+
+        <tr>
+            <td>Input a sentence (or an image URL)</td>
+            <td><textarea v-model="query"
+                          placeholder="Input a sentence or an image URL"
+                          style="width: 80%"
+                          rows="6"
+                          maxlength="1000">
+            </textarea></td>
+        </tr>
+
+        <tr>
+            <td>Click an image to select</td>
+            <td>
+                <div class="gallery">
+                    <img @click="query='https://picsum.photos/id/'+image.id+'/50'" class="gallery-image"
+                         :src="'https://picsum.photos/id/'+image.id+'/80'" v-for="image in images">
+                </div>
+            </td>
+        </tr>
+
+        <tr>
+            <td>Upload image from local</td>
+            <td><input type="file" @change="encodeImageFileAsURL" accept=".jpg, .jpeg, .png"/></td>
+        </tr>
+
+    </table>
+
+    <div v-if="query && embedding" class="embeddingChart">
+
+        <div>
+            <p>Done in {{elapsed}}ms
+            <img class="thumbnail" v-if="isUrl" :src="query" :alt="query + 'is not a valid image'">
+            <code v-else>{{query}}</code>
+            </p>
+        </span>
+        </div>
+
+        <div class="embeddingBlock" v-for="value in embedding" v-bind:style="{opacity: normalize_value(value)}"
+             v-bind:title="value">
+            <span v-if="showValue">{{value.toString().charAt(3)}}</span>
+        </div>
+
+        <div>
+
+            <input type="checkbox" id="checkbox" v-model="showValue"/>
+            <label for="checkbox">Show embedding values (that visually make no sense but people like it as it was doing
+                some real science stuff)</label>
+        </div>
+
+    </div>
+
+
+</div>
+
+<style>
+    #demo-embed {
+        font-family: var(--font-stack) !important;
+    }
+
+    .gallery-image:hover {
+        opacity: 100%;
+    }
+
+    .gallery-image {
+        opacity: 50%;
+        transition: opacity 0.3s;
+        -webkit-transition: opacity 0.3s;
+        cursor: pointer;
+    }
+
+    .thumbnail {
+        max-width: 64px;
+        max-height: 64px;
+    }
+
+    .embeddingChart {
+        margin-top: 30px;
+        margin-bottom: 30px;
+    }
+
+    .embeddingBlock {
+        width: 8px;
+        height: 8px;
+        display: inline-flex;
+        background: green;
+        border-style: solid;
+        border-color: white;
+        border-width: 1px;
+        font-size: 1vmin;
+        color: white;
+        text-align: center;
+        vertical-align: middle;
+        justify-content: center;
+        align-items: center;
+        transition: opacity 0.3s;
+        -webkit-transition: opacity 0.3s;
+        cursor: pointer;
+    }
+
+    .embeddingBlock:hover {
+        border-color: green;
+    }
+
+
+</style>
+
+<script>
+    function randomIntFromInterval(min, max) { // min and max included
+        return Math.floor(Math.random() * (max - min + 1) + min)
+    }
+
+    var app = new Vue({
+        el: '#demo-embed',
+        data: {
+            serverAddress: `https://api.clip.jina.ai:8443`,
+            query: 'First do it, then do it right, then do it better',
+            embedding: [1, 1, 1],
+            max_embed_value: 0,
+            min_embed_value: 0,
+            elapsed: 0,
+            showValue: true,
+            images: []
+        },
+        computed: {
+            isUrl: function () {
+                let url;
+
+                try {
+                    url = new URL(this.query);
+                } catch (_) {
+                    return false;
+                }
+
+                return url.protocol === "http:" || url.protocol === "https:" || url.protocol === "data:";
+            },
+            // get only
+            payload: function () {
+                return {
+                    data: [this.isUrl ? {
+                        uri: this.query
+                    } : {
+                        text: this.query
+                    }],
+                    exec_endpoint: '/',
+                }
+            }
+        },
+        mounted: function () {
+            this.$nextTick(function () {
+                app.callJina();
+
+                $.getJSON("https://picsum.photos/v2/list?page=" + randomIntFromInterval(1, 40) + "&limit=10", function (json) {
+                    app.images = json
+                });
+
+            })
+        },
+        watch: {
+            query: function (newQ, oldQ) {
+                this.callJina()
+            }
+        },
+        methods: {
+            encodeImageFileAsURL(element) {
+                var file = element.target.files[0];
+                var reader = new FileReader();
+                reader.onloadend = function () {
+                    app.query = reader.result
+                }
+                reader.readAsDataURL(file);
+            },
+            normalize_value(val) {
+                r = (val - this.min_embed_value) / (this.max_embed_value - this.min_embed_value)
+                r = (r * 10).toFixed(0) / 10
+                return r
+            },
+            callJina: function () {
+
+                $.ajax({
+                    headers: {
+                        Authorization: "d28b93ccbd13367148d05fe3f7fbc680"
+                    },
+                    type: "POST",
+                    url: this.serverAddress + "/post",
+                    data: JSON.stringify(this.payload),
+                    contentType: "application/json; charset=utf-8",
+                    dataType: "json",
+                }).success(function (data, textStatus, jqXHR) {
+                    // data.data[0].embedding
+                    app.embedding = data.data[0].embedding
+                    app.max_embed_value = Math.max.apply(null, app.embedding)
+                    app.min_embed_value = Math.min.apply(null, app.embedding)
+
+                    date1 = new Date(data.routes[0].startTime)
+                    date2 = new Date(data.routes[0].endTime)
+                    app.elapsed = date2 - date1
+
+                }).fail(function () {
+                    console.error("bad connection!")
+                });
+            }
+        }
+    })
+
+</script>

clip_as_service/docs/_static/demo-text-rank.html

@@ -0,0 +1,245 @@
+<script src="https://cdn.jsdelivr.net/npm/vue@2/dist/vue.js"></script>
+<script src='https://cdnjs.cloudflare.com/ajax/libs/jquery/2.1.3/jquery.min.js'></script>
+
+<div id="demo-embed">
+    <table class="embeddingInput">
+        <tr>
+            <td>Input an image URL</td>
+            <td><input v-model="query"
+                       placeholder="Input an image URL"
+                       style="width: 80%"
+                       maxlength="1000"></td>
+        </tr>
+
+        <tr>
+            <td>Click an image to select</td>
+            <td>
+                <div class="gallery">
+                    <img @click="query='https://picsum.photos/id/'+image.id+'/50'" class="gallery-image"
+                         :src="'https://picsum.photos/id/'+image.id+'/80'" v-for="image in images">
+                </div>
+            </td>
+        </tr>
+
+        <tr>
+            <td>Upload image from local</td>
+            <td><input type="file" @change="encodeImageFileAsURL" accept=".jpg, .jpeg, .png"/></td>
+        </tr>
+
+    </table>
+
+    <p>
+        <button v-on:click="addPrompt">+ Add prompt</button>
+        <button v-on:click="rmPrompt">- Remove prompt</button>
+    </p>
+    <li v-for="item in prompts" :key="item.id">
+        <input v-model="item.text" placeholder="edit me" size="50">
+    </li>
+
+    <p>
+        <div v-if="query && embedding" class="embeddingChart">
+
+            <div>
+                <p>Done in {{elapsed}}ms
+                <span>
+                    <img class="thumbnail" v-if="isUrl" :src="query" :alt="query + 'is not a valid image'">
+                    <code v-else>{{query}}</code>
+                </span>
+                </p>
+            </div>
+
+        </div>
+    </p>
+    <p>
+    Showing reasoning results (score in softmax):
+    <table>
+        <tr v-for="item in matches">
+            <td style="width: 300px"
+                :style="{background: 'linear-gradient(90deg, #00bfa5 ' +(item.scores['clip_score'].value * 100).toFixed(2) + '%, #b5f6e9 '+ (item.scores['clip_score'].value * 100).toFixed(2) + '%)'}">
+                {{item.text}}
+            </td>
+            <td>{{(item.scores['clip_score'].value * 100).toFixed(2)}}</td>
+        </tr>
+    </table>
+    </p>
+</div>
+
+<style>
+    #demo-embed {
+        font-family: var(--font-stack) !important;
+    }
+
+    .scorebar {
+        background: #00bfa5;
+    }
+
+    .gallery-image:hover {
+        opacity: 100%;
+    }
+
+    .gallery-image {
+        opacity: 50%;
+        transition: opacity 0.3s;
+        -webkit-transition: opacity 0.3s;
+        cursor: pointer;
+    }
+
+    .preview-image {
+        width: 100px
+    }
+
+    .thumbnail {
+        max-width: 64px;
+        max-height: 64px;
+    }
+
+    .embeddingChart {
+        margin-top: 30px;
+        margin-bottom: 30px;
+    }
+
+    .embeddingBlock {
+        width: 8px;
+        height: 8px;
+        display: inline-flex;
+        background: green;
+        border-style: solid;
+        border-color: white;
+        border-width: 1px;
+        font-size: 1vmin;
+        color: white;
+        text-align: center;
+        vertical-align: middle;
+        justify-content: center;
+        align-items: center;
+        transition: opacity 0.3s;
+        -webkit-transition: opacity 0.3s;
+        cursor: pointer;
+    }
+
+    .embeddingBlock:hover {
+        border-color: green;
+    }
+
+
+</style>
+
+<script>
+    function randomIntFromInterval(min, max) { // min and max included
+        return Math.floor(Math.random() * (max - min + 1) + min)
+    }
+
+    var app = new Vue({
+        el: '#demo-embed',
+        data: {
+            serverAddress: `https://api.clip.jina.ai:8443`,
+            query: 'https://picsum.photos/300',
+            embedding: [1, 1, 1],
+            max_embed_value: 0,
+            min_embed_value: 0,
+            elapsed: 0,
+            showValue: true,
+            images: [],
+            matches: [],
+            prompts: [
+                {"text": "This is a photo of natural scene"},
+                {"text": "This is a photo of man-made object"},
+                {"text": "This is a photo of an animal"},
+                {"text": "This is a photo with human faces"},
+                {"text": "This is a blurry photo"},
+                {"text": "This is a black and white photo"},
+                {"text": "This is a screenshot"},
+            ]
+        },
+        computed: {
+            isUrl: function () {
+                let url;
+
+                try {
+                    url = new URL(this.query);
+                } catch (_) {
+                    return false;
+                }
+
+                return url.protocol === "http:" || url.protocol === "https:" || url.protocol === "data:";
+            },
+            // get only
+            payload: function () {
+                return {
+                    data: [this.isUrl ? {
+                        uri: this.query,
+                        matches: this.prompts
+                    } : {
+                        text: this.query,
+                        matches: this.prompts
+                    }],
+                    exec_endpoint: '/rank',
+                }
+            }
+        },
+        mounted: function () {
+            this.$nextTick(function () {
+                app.callJina();
+
+                $.getJSON("https://picsum.photos/v2/list?page=" + randomIntFromInterval(1, 40) + "&limit=10", function (json) {
+                    app.images = json
+                });
+
+            })
+        },
+        watch: {
+            query: function (newQ, oldQ) {
+                this.callJina()
+            },
+            prompts: {
+                handler: function (newQ, oldQ) {
+                    this.callJina()
+                }, deep: true
+            },
+        },
+        methods: {
+            encodeImageFileAsURL(element) {
+                var file = element.target.files[0];
+                var reader = new FileReader();
+                reader.onloadend = function () {
+                    app.query = reader.result
+                }
+                reader.readAsDataURL(file);
+            },
+            addPrompt: function () {
+                this.prompts.push({"text": "write your prompt here"})
+            },
+            rmPrompt: function () {
+                this.prompts.pop()
+            },
+            normalize_value(val) {
+                r = (val - this.min_embed_value) / (this.max_embed_value - this.min_embed_value)
+                r = (r * 10).toFixed(0) / 10
+                return r
+            },
+            callJina: function () {
+
+                $.ajax({
+                    headers: {
+                        Authorization: "d28b93ccbd13367148d05fe3f7fbc680"
+                    },
+                    type: "POST",
+                    url: this.serverAddress + "/post",
+                    data: JSON.stringify(this.payload),
+                    contentType: "application/json; charset=utf-8",
+                    dataType: "json",
+                }).success(function (data, textStatus, jqXHR) {
+                    // data.data[0].embedding
+                    app.matches = data.data[0].matches
+                    date1 = new Date(data.routes[0].startTime)
+                    date2 = new Date(data.routes[0].endTime)
+                    app.elapsed = date2 - date1
+
+                }).fail(function () {
+                    console.error("bad connection!")
+                });
+            }
+        }
+    })
+
+</script>

clip_as_service/docs/_static/main.css

@@ -0,0 +1,175 @@
+html.loaded-in-iframe #announcement,
+html.loaded-in-iframe #sidebar-drawer,
+html.loaded-in-iframe footer,
+html.loaded-in-iframe #toc-drawer {
+  display: none!important;
+}
+
+html.loaded-in-iframe .page .main {
+    justify-content: center;
+}
+
+.sidebar-logo {
+    max-width: 70%;
+}
+
+
+table.docutils {
+    border: thin;
+}
+
+table.docutils td, table.docutils th {
+    padding: 1rem 1rem;
+}
+
+.highlight {
+    background: #f5f5f5;
+}
+
+h1, h2, h3 {
+    margin-top: 3rem;
+}
+
+.highlight-console .highlight {
+    background: #00232b !important;
+    color: whitesmoke;
+}
+
+.highlight-text .highlight {
+    background: #00232b !important;
+    color: whitesmoke;
+}
+
+.highlight-json .highlight {
+    background: #00232b !important;
+    color: whitesmoke;
+}
+
+.highlight-shell .highlight {
+    background: #00232b !important;
+    color: whitesmoke;
+}
+
+.highlight-bash .highlight {
+    background: #00232b !important;
+    color: whitesmoke;
+}
+
+.tab-set > input:checked + label {
+    border-color: var(--tabs--label-text--active);
+}
+
+.tab-set > input:checked + label:hover {
+    border-color: var(--tabs--label-text--active);
+}
+
+
+table code {
+    background: var(--color-inline-code-background);
+    border: 1px solid var(--color-background-border);
+    border-radius: .2em;
+    font-size: var(--font-size--small--2);
+    padding: .1em .2em;
+}
+
+.related-information {
+    justify-content: space-between;
+}
+
+.social-btn {
+    margin: 0 .3em;
+}
+
+.social-btn:hover {
+    opacity: .5;
+}
+
+.social-btns {
+    display: inline-block;
+}
+
+.announcement {
+    background-color: var(--color-brand-primary);
+    color: var(--color-background-primary) !important;
+}
+
+.announcement a {
+    color: inherit;
+    text-decoration: none;
+}
+
+.announcement a:hover {
+    color: inherit;
+    text-decoration: underline;
+}
+
+.sidebar-ecosys-logo {
+    width: 1.2em;
+    margin-right: .5em;
+    vertical-align: middle
+}
+
+
+body[data-theme="dark"] .only-dark-line {
+    display: inline-block !important;
+}
+
+body[data-theme="dark"] .only-light-line {
+    display: none !important;
+}
+
+body[data-theme="light"] .only-light-line {
+    display: inline-block !important;
+}
+
+body[data-theme="light"] .only-dark-line {
+    display: none !important;
+}
+
+body[data-theme="auto"] .only-light-line {
+    display: inline-block !important;
+}
+
+body[data-theme="auto"] .only-dark-line {
+    display: none !important;
+}
+
+.color-gradient-card {
+    background: linear-gradient(270deg, #22c1c3, #fdbb2d);
+    background-size: 200% 200%;
+
+    -webkit-animation: AnimationName 30s ease infinite;
+    -moz-animation: AnimationName 30s ease infinite;
+    animation: AnimationName 30s ease infinite;
+}
+
+@-webkit-keyframes AnimationName {
+    0%{background-position:0% 50%}
+    50%{background-position:100% 50%}
+    100%{background-position:0% 50%}
+}
+@-moz-keyframes AnimationName {
+    0%{background-position:0% 50%}
+    50%{background-position:100% 50%}
+    100%{background-position:0% 50%}
+}
+@keyframes AnimationName {
+    0%{background-position:0% 50%}
+    50%{background-position:100% 50%}
+    100%{background-position:0% 50%}
+}
+
+.version-select {
+    font-size: .7em;
+    border-radius: 5px;
+    cursor: pointer;
+    background-color: #fff;
+    background-image: linear-gradient(to top, #f9f9f9, #fff 33%);
+    border-color: var(--color-background-border);
+    height: 1.8em;
+    line-height: 1.8em;
+    outline: none;
+    text-align: center;
+    max-width: 7em;
+    color: var(--color-foreground-muted);
+}

clip_as_service/docs/_templates/page.html

@@ -0,0 +1,230 @@
+{% extends "base.html" %}
+
+{% block body -%}
+{{ super() }}
+{% include "partials/icons.html" %}
+
+<input type="checkbox" class="sidebar-toggle" name="__navigation" id="__navigation">
+<input type="checkbox" class="sidebar-toggle" name="__toc" id="__toc">
+<label class="overlay sidebar-overlay" for="__navigation">
+    <div class="visually-hidden">Hide navigation sidebar</div>
+</label>
+<label class="overlay toc-overlay" for="__toc">
+    <div class="visually-hidden">Hide table of contents sidebar</div>
+</label>
+
+{% if theme_announcement -%}
+<div class="announcement">
+    <aside class="announcement-content">
+        {% block announcement %} {{ theme_announcement }} {% endblock announcement %}
+    </aside>
+</div>
+{%- endif %}
+
+<div class="page">
+    <header class="mobile-header">
+        <div class="header-left">
+            <label class="nav-overlay-icon" for="__navigation">
+                <div class="visually-hidden">Toggle site navigation sidebar</div>
+                <i class="icon">
+                    <svg>
+                        <use href="#svg-menu"></use>
+                    </svg>
+                </i>
+            </label>
+        </div>
+        <div class="header-center">
+            <a href="{{ pathto(master_doc) }}">
+                <div class="brand">{{ docstitle if docstitle else project }}</div>
+            </a>
+        </div>
+        <div class="header-right">
+            <div class="theme-toggle-container theme-toggle-header">
+                <button class="theme-toggle">
+                    <div class="visually-hidden">Toggle Light / Dark / Auto color theme</div>
+                    <svg class="theme-icon-when-auto">
+                        <use href="#svg-sun-half"></use>
+                    </svg>
+                    <svg class="theme-icon-when-dark">
+                        <use href="#svg-moon"></use>
+                    </svg>
+                    <svg class="theme-icon-when-light">
+                        <use href="#svg-sun"></use>
+                    </svg>
+                </button>
+            </div>
+            <label class="toc-overlay-icon toc-header-icon{% if furo_hide_toc %} no-toc{% endif %}" for="__toc">
+                <div class="visually-hidden">Toggle table of contents sidebar</div>
+                <i class="icon">
+                    <svg>
+                        <use href="#svg-toc"></use>
+                    </svg>
+                </i>
+            </label>
+        </div>
+    </header>
+    <aside class="sidebar-drawer">
+        <div class="sidebar-container">
+            {% block left_sidebar %}
+            <div class="sidebar-sticky">
+                {%- for sidebar_section in sidebars %}
+                {%- include sidebar_section %}
+                {%- endfor %}
+            </div>
+            {% endblock left_sidebar %}
+        </div>
+    </aside>
+    <div class="main">
+        <div class="content">
+            <div class="article-container">
+                <a href="#" class="back-to-top muted-link">
+                    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+                        <path d="M13 20h-2V8l-5.5 5.5-1.42-1.42L12 4.16l7.92 7.92-1.42 1.42L13 8v12z"></path>
+                    </svg>
+                    <span>{% trans %}Back to top{% endtrans %}</span>
+                </a>
+                <div class="content-icon-container">
+                    {#- Edit this page, on GitHub -#}
+                    {%- if READTHEDOCS and conf_py_path and page_source_suffix and github_user != "None" and github_repo
+                    != "None" and github_version %}
+                    <div class="edit-this-page">
+                        <a class="muted-link"
+                           href="https://github.com/{{ github_user }}/{{ github_repo }}/edit/{{ github_version }}{{ conf_py_path }}{{ pagename }}{{ page_source_suffix }}"
+                           title="{{ _(" Edit this page") }}">
+                        <svg aria-hidden="true" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" fill="none"
+                             stroke-linecap="round" stroke-linejoin="round">
+                            <path stroke="none" d="M0 0h24v24H0z" fill="none"/>
+                            <path d="M4 20h4l10.5 -10.5a1.5 1.5 0 0 0 -4 -4l-10.5 10.5v4"/>
+                            <line x1="13.5" y1="6.5" x2="17.5" y2="10.5"/>
+                        </svg>
+                        <span class="visually-hidden">{{ _("Edit this page") }}</span>
+                        </a>
+                    </div>
+                    {% endif %}
+                    {#- Theme toggle -#}
+                    <div class="theme-toggle-container theme-toggle-content">
+                        <button class="theme-toggle">
+                            <div class="visually-hidden">Toggle Light / Dark / Auto color theme</div>
+                            <svg class="theme-icon-when-auto">
+                                <use href="#svg-sun-half"></use>
+                            </svg>
+                            <svg class="theme-icon-when-dark">
+                                <use href="#svg-moon"></use>
+                            </svg>
+                            <svg class="theme-icon-when-light">
+                                <use href="#svg-sun"></use>
+                            </svg>
+                        </button>
+                    </div>
+                    <label class="toc-overlay-icon toc-content-icon{% if furo_hide_toc %} no-toc{% endif %}"
+                           for="__toc">
+                        <div class="visually-hidden">Toggle table of contents sidebar</div>
+                        <i class="icon">
+                            <svg>
+                                <use href="#svg-toc"></use>
+                            </svg>
+                        </i>
+                    </label>
+                </div>
+                <article role="main">
+                    {% block content %}{{ body }}{% endblock %}
+                </article>
+            </div>
+            <footer>
+                {% block footer %}
+                <div class="related-pages">
+                    {% if next -%}
+                    <a class="next-page" href="{{ next.link }}">
+                        <div class="page-info">
+                            <div class="context">
+                                <span>{{ _("Next") }}</span>
+                            </div>
+                            <div class="title">{{ next.title }}</div>
+                        </div>
+                        <svg class="furo-related-icon">
+                            <use href="#svg-arrow-right"></use>
+                        </svg>
+                    </a>
+                    {%- endif %}
+                    {% if prev -%}
+                    <a class="prev-page" href="{{ prev.link }}">
+                        <svg class="furo-related-icon">
+                            <use href="#svg-arrow-right"></use>
+                        </svg>
+                        <div class="page-info">
+                            <div class="context">
+                                <span>{{ _("Previous") }}</span>
+                            </div>
+                            {% if prev.link == pathto(master_doc) %}
+                            <div class="title">{{ _("Home") }}</div>
+                            {% else %}
+                            <div class="title">{{ prev.title }}</div>
+                            {% endif %}
+                        </div>
+                    </a>
+                    {%- endif %}
+                </div>
+                <div class="bottom-of-page">
+                    <div class="left-details">
+                        {%- if show_copyright %}
+                        <div class="copyright">
+                            {%- if hasdoc('copyright') %}
+                            {% trans path=pathto('copyright'), copyright=copyright|e -%}
+                            <a href="{{ path }}">Copyright</a> &#169; {{ copyright }}
+                            {%- endtrans %}
+                            {%- else %}
+                            {% trans copyright=copyright|e -%}
+                            Copyright &#169; {{ copyright }}
+                            {%- endtrans %}
+                            {%- endif %}
+                        </div>
+                        {%- endif %}
+                        {%- if last_updated -%}
+                        <div class="last-updated">
+                            {% trans last_updated=last_updated|e -%}
+                            Last updated on {{ last_updated }}
+                            {%- endtrans -%}
+                        </div>
+                        {%- endif %}
+                    </div>
+                    <div class="right-details">
+                        <div class="social-btns">
+                            <a class='social-btn' href="https://github.com/jina-ai/clip-as-service/" aria-label="GitHub"
+                               target="_blank" rel="noreferrer"> <i class="fab fa-github"></i></a>
+                            <a class='social-btn' href="https://discord.jina.ai" aria-label="Discord" target="_blank"
+                               rel="noreferrer"> <i class="fab fa-discord"></i></a>
+                            <a class='social-btn' href="https://youtube.com/c/jina-ai" aria-label="YouTube"
+                               target="_blank" rel="noreferrer"> <i class="fab fa-youtube"></i></a>
+                            <a class='social-btn' href="https://twitter.com/JinaAI_" aria-label="Twitter"
+                               target="_blank" rel="noreferrer"> <i class="fab fa-twitter"></i></a>
+                            <a class='social-btn' href="https://www.linkedin.com/company/jinaai/" aria-label="LinkedIn"
+                               target="_blank" rel="noreferrer"> <i class="fab fa-linkedin"></i></a>
+                        </div>
+                    </div>
+                </div>
+                {% endblock footer %}
+            </footer>
+        </div>
+        <aside class="toc-drawer{% if furo_hide_toc %} no-toc{% endif %}">
+            {% block right_sidebar %}
+            {% if not furo_hide_toc %}
+            <div class="toc-sticky toc-scroll">
+                <div class="toc-title-container">
+          <span class="toc-title">
+            {{ _("Contents") }}
+          </span>
+                </div>
+                <div class="toc-tree-container">
+                    <div class="toc-tree">
+                        {{ toc }}
+                    </div>
+                </div>
+            </div>
+            {% endif %}
+            {% endblock right_sidebar %}
+        </aside>
+    </div>
+</div>
+<img referrerpolicy="no-referrer-when-downgrade"
+     src="https://static.scarf.sh/a.png?x-pxid=2823e771-0e1e-4320-8fde-48bc48e53262"/>
+{%- endblock %}

clip_as_service/docs/_templates/sidebar/brand.html

@@ -0,0 +1,41 @@
+<a class="sidebar-brand{% if logo %} centered{% endif %}" href="{{ pathto(master_doc) }}">
+  {% block brand_content %}
+  {%- if logo_url %}
+  <div class="sidebar-logo-container">
+    <img class="sidebar-logo" src="{{ logo_url }}" alt="Logo" />
+  </div>
+  {%- endif %}
+  {%- if theme_light_logo and theme_dark_logo %}
+  <div class="sidebar-logo-container">
+    <img class="sidebar-logo only-light" src="{{ pathto('_static/' + theme_light_logo, 1) }}" alt="Light Logo" />
+    <img class="sidebar-logo only-dark" src="{{ pathto('_static/' + theme_dark_logo, 1) }}" alt="Dark Logo" />
+  </div>
+  {%- endif %}
+  {% if not theme_sidebar_hide_name %}
+  <span class="sidebar-brand-text">{{ docstitle if docstitle else project }}</span>
+  {%- endif %}
+  {% endblock brand_content %}
+</a>
+<div class="sd-d-flex-row sd-align-major-spaced">
+  <a class="github-button" href="https://github.com/jina-ai/clip-as-service" data-icon="octicon-star" data-show-count="true" aria-label="Star jina-ai/jina on GitHub" style="opacity: 0;">Star</a>
+  {% if versions %}
+  <select onChange="window.location.href=this.value" class="version-select">
+      {%- for item in versions|reverse %}
+        {% if item.name == latest_jina_version %}
+          {% set new_url = item.url if current_version.name == latest_jina_version else item.url | replace('/' + latest_jina_version, "") %}
+          {% if current_version.version == item.version %}
+            <option value="{{ new_url }}" selected="selected" >latest ({{ item.name }})</option>
+          {% else %}
+            <option value="{{ new_url }}" >latest({{ item.name }})</option>
+          {% endif %}
+        {% else %}
+          {% if current_version.version == item.version %}
+            <option value="{{ item.url }}" selected="selected" >{{ item.name }}</option>
+          {% else %}
+            <option value="{{ item.url }}" >{{ item.name }}</option>
+          {% endif %}
+        {% endif %}
+      {%- endfor %}
+  </select>
+  {% endif %}
+</div>

clip_as_service/docs/_templates/sidebar/navigation.html

@@ -0,0 +1,35 @@
+<div class="sidebar-tree">
+    {{ furo_navigation_tree }}
+    <p class="caption" role="heading"><span class="caption-text">Ecosystem</span></p>
+    <ul>
+        <li class="toctree-l1">
+            <a class="reference external" href="https://docs.jina.ai">
+                <img class="sidebar-ecosys-logo only-light-line" src="{{ pathto('_static/search-light.svg', 1) }}">
+                <img class="sidebar-ecosys-logo only-dark-line" src="{{ pathto('_static/search-dark.svg', 1) }}">
+                Jina</a></li>
+        <li class="toctree-l1"><a class="reference external" href="https://hub.jina.ai">
+            <img class="sidebar-ecosys-logo only-light-line" src="{{ pathto('_static/hub-light.svg', 1) }}">
+            <img class="sidebar-ecosys-logo only-dark-line" src="{{ pathto('_static/hub-dark.svg', 1) }}">
+            Jina Hub</a></li>
+        <li class="toctree-l1"><a class="reference external" href="https://finetuner.jina.ai">
+            <img class="sidebar-ecosys-logo only-light-line" src="{{ pathto('_static/finetuner-light.svg', 1) }}">
+            <img class="sidebar-ecosys-logo only-dark-line" src="{{ pathto('_static/finetuner-dark.svg', 1) }}">
+            Finetuner</a></li>
+        <li class="toctree-l1"><a class="reference external" href="https://docarray.jina.ai">
+            <img class="sidebar-ecosys-logo only-light-line" src="{{ pathto('_static/docarray-light.svg', 1) }}">
+            <img class="sidebar-ecosys-logo only-dark-line" src="{{ pathto('_static/docarray-dark.svg', 1) }}">
+            DocArray</a></li>
+        <li class="toctree-l1"><a class="reference internal" href="#">
+            <img class="sidebar-ecosys-logo only-light-line" src="{{ pathto('_static/cas-light.svg', 1) }}">
+            <img class="sidebar-ecosys-logo only-dark-line" src="{{ pathto('_static/cas-dark.svg', 1) }}">
+            CLIP-as-service</a></li>
+        <li class="toctree-l1"><a class="reference external" href="https://github.com/jina-ai/jcloud">
+            <img class="sidebar-ecosys-logo only-light-line" src="{{ pathto('_static/JCloud-light.svg', 1) }}">
+            <img class="sidebar-ecosys-logo only-dark-line" src="{{ pathto('_static/JCloud-dark.svg', 1) }}">
+            JCloud</a></li>
+        <li class="toctree-l1"><a class="reference external" href="https://now.jina.ai">
+            <img class="sidebar-ecosys-logo only-light-line" src="{{ pathto('_static/now-light.svg', 1) }}">
+            <img class="sidebar-ecosys-logo only-dark-line" src="{{ pathto('_static/now-dark.svg', 1) }}">
+            NOW</a></li>
+    </ul>
+</div>

clip_as_service/docs/changelog/index.md

@@ -0,0 +1,22 @@
+# Changelog
+
+CLIP-as-service follows semantic versioning. However, before the project reach 1.0.0, any breaking change will only bump the minor version.  An automated release note is [generated on every release](https://github.com/jina-ai/clip-as-service/releases). The release note includes features, bugs, refactorings etc. 
+
+This chapter only tracks the most important breaking changes and explain the rationale behind them.
+
+## 0.4.0: rename `rerank` concept to `rank`
+
+"Reranking" is a new feature introduced since 0.3.3. This feature allows user to rank and score `document.matches` in a cross-modal way. From 0.4.0, this feature as well as all related functions will refer it simply as "rank".
+
+## 0.2.0: improve the service scalability with replicas
+
+This change is mainly intended to improve the inference performance with replicas.
+
+Here is the short benchmark summary of the improvement (`replicas=4`):
+
+| batch_size  | before | after   |
+|-------------|--------|---------|
+| 1           | 23.74  | 18.89   |
+| 8           | 58.88  | 30.38   |
+| 16          | 14.96  | 91.86   |
+| 32          | 14.78  | 101.75  |

clip_as_service/docs/conf.py

@@ -0,0 +1,220 @@
+import os
+import re
+import sys
+from os import path
+
+sys.path.insert(0, path.abspath('..'))
+
+project = 'CLIP-as-service'
+slug = re.sub(r'\W+', '-', project.lower())
+author = 'Jina AI'
+copyright = 'Jina AI Limited. All rights reserved.'
+source_suffix = ['.rst', '.md']
+master_doc = 'index'
+language = 'en'
+repo_dir = '../'
+
+try:
+    if 'CAS_VERSION' not in os.environ:
+        libinfo_py = path.join(repo_dir, 'client/clip_client', '__init__.py')
+        libinfo_content = open(libinfo_py, 'r').readlines()
+        version_line = [
+            l.strip() for l in libinfo_content if l.startswith('__version__')
+        ][0]
+        exec(version_line)
+    else:
+        __version__ = os.environ['CAS_VERSION']
+except FileNotFoundError:
+    __version__ = '0.0.0'
+
+version = __version__
+release = __version__
+
+templates_path = ['_templates']
+exclude_patterns = [
+    '_build',
+    'Thumbs.db',
+    '.DS_Store',
+    'tests',
+    'page_templates',
+    '.github',
+]
+pygments_style = 'rainbow_dash'
+html_theme = 'furo'
+
+base_url = '/'
+html_baseurl = 'https://clip-as-service.jina.ai'
+sitemap_url_scheme = '{link}'
+sitemap_locales = [None]
+sitemap_filename = "sitemap.xml"
+
+html_theme_options = {
+    'light_logo': 'logo-light.svg',
+    'dark_logo': 'logo-dark.svg',
+    "sidebar_hide_name": True,
+    "light_css_variables": {
+        "color-brand-primary": "#009191",
+        "color-brand-content": "#009191",
+    },
+    "dark_css_variables": {
+        "color-brand-primary": "#FBCB67",
+        "color-brand-content": "#FBCB67",
+    },
+    # PLEASE DO NOT DELETE the empty line between `start-announce` and `end-announce`
+    # PLEASE DO NOT DELETE `start-announce`/ `end-announce` it is used for our dev bot to inject announcement from GH
+    # start-announce
+    # end-announce
+}
+
+html_static_path = ['_static']
+html_extra_path = ['html_extra']
+html_css_files = [
+    'main.css',
+    'https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0-beta2/css/all.min.css',
+]
+html_js_files = [
+    'https://cdn.jsdelivr.net/npm/vue@2/dist/vue.min.js',
+]
+htmlhelp_basename = slug
+html_show_sourcelink = False
+html_favicon = '_static/favicon.png'
+
+intersphinx_mapping = {'docarray': ('https://docarray.jina.ai/', None), 'finetuner': ('https://finetuner.jina.ai/', None)}
+
+latex_documents = [(master_doc, f'{slug}.tex', project, author, 'manual')]
+man_pages = [(master_doc, slug, project, [author], 1)]
+texinfo_documents = [
+    (master_doc, slug, project, author, slug, project, 'Miscellaneous')
+]
+epub_title = project
+epub_exclude_files = ['search.html']
+
+# -- Extension configuration -------------------------------------------------
+
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx_autodoc_typehints',
+    'sphinx.ext.viewcode',
+    'sphinx.ext.coverage',
+    'sphinxcontrib.apidoc',
+    'sphinxarg.ext',
+    'sphinx_copybutton',
+    'sphinx_sitemap',
+    'sphinx.ext.intersphinx',
+    'sphinxext.opengraph',
+    'notfound.extension',
+    'myst_parser',
+    'sphinx_design',
+    'sphinx_inline_tabs',
+]
+
+myst_enable_extensions = ['colon_fence', 'substitution', 'deflist']
+
+# -- Custom 404 page
+
+# sphinx-notfound-page
+# https://github.com/readthedocs/sphinx-notfound-page
+notfound_context = {
+    'title': 'Page Not Found',
+    'body': '''
+<h1>Page Not Found</h1>
+<p>Oops, we couldn't find that page. </p>
+<p>You can try "asking our docs" on the right corner of the page to find answer.</p>
+<p>Otherwise, <a href="https://github.com/jina-ai/clip-as-service/">please create a Github issue</a> and one of our team will respond.</p>
+
+''',
+}
+notfound_no_urls_prefix = True
+
+apidoc_module_dir = '../client'
+apidoc_output_dir = 'api'
+apidoc_excluded_paths = ['tests', 'legacy', 'hub', 'toy*', 'setup.py']
+apidoc_separate_modules = True
+apidoc_extra_args = ['-t', 'template/']
+autodoc_member_order = 'bysource'
+autodoc_mock_imports = ['argparse', 'numpy', 'np', 'tensorflow', 'torch', 'scipy']
+autoclass_content = 'both'
+set_type_checking_flag = False
+html_last_updated_fmt = ''
+nitpicky = True
+nitpick_ignore = [('py:class', 'type')]
+linkcheck_ignore = [
+    # Avoid link check on local uri
+    'http://0.0.0.0:*',
+    'pods/encode.yml',
+    'https://github.com/jina-ai/clip-as-service/commit/*',
+    '.github/*',
+    'extra-requirements.txt',
+    'fastentrypoints.py' '../../101',
+    '../../102',
+    'http://www.twinsun.com/tz/tz-link.htm',  # Broken link from pytz library
+    'https://urllib3.readthedocs.io/en/latest/contrib.html#google-app-engine',  # Broken link from urllib3 library
+    'https://linuxize.com/post/how-to-add-swap-space-on-ubuntu-20-04/',
+    # This link works but gets 403 error on linkcheck
+]
+linkcheck_timeout = 20
+linkcheck_retries = 2
+linkcheck_anchors = False
+
+ogp_site_url = 'https://clip-as-service.jina.ai/'
+ogp_image = 'https://clip-as-service.jina.ai/_static/banner.png'
+ogp_use_first_image = True
+ogp_description_length = 300
+ogp_type = 'website'
+ogp_site_name = f'CLIP-as-service {os.environ.get("SPHINX_MULTIVERSION_VERSION", version)} Documentation'
+
+ogp_custom_meta_tags = [
+    '<meta name="twitter:card" content="summary_large_image">',
+    '<meta name="twitter:site" content="@JinaAI_">',
+    '<meta name="twitter:creator" content="@JinaAI_">',
+    '<meta name="description" content="Embed images and sentences into fixed-length vectors via CLIP.">',
+    '<meta property="og:description" content="CLIP-as-service is a low-latency high-scalability embedding service for images and texts. It can be easily integrated as a microservice into neural search solutions.">',
+    '''
+
+<script async src="https://www.googletagmanager.com/gtag/js?id=G-E63SXVNDXZ"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+
+  gtag('config', 'G-E63SXVNDXZ');
+</script>
+
+<script async defer src="https://buttons.github.io/buttons.js"></script>
+    ''',
+]
+
+
+def add_server_address(app):
+    # This makes variable `server_address` available to docbot.js
+    server_address = app.config['server_address']
+    js_text = "var server_address = '%s';" % server_address
+    app.add_js_file(None, body=js_text)
+
+
+def setup(app):
+    from sphinx.domains.python import PyField
+    from sphinx.util.docfields import Field
+    from sphinx.locale import _
+
+    app.add_object_type(
+        'confval',
+        'confval',
+        objname='configuration value',
+        indextemplate='pair: %s; configuration value',
+        doc_field_types=[
+            PyField(
+                'type',
+                label=_('Type'),
+                has_arg=False,
+                names=('type',),
+                bodyrolename='class',
+            ),
+            Field(
+                'default',
+                label=_('Default'),
+                has_arg=False,
+                names=('default',),
+            ),
+        ],
+    )

clip_as_service/docs/hosting/by-jina.md

@@ -0,0 +1,70 @@
+# Hosted by Jina AI
+
+```{include} ../../README.md
+:start-after: <!-- start inference-banner -->
+:end-before: <!-- end inference-banner -->
+```
+
+In today's dynamic business environment, enterprises face a multitude of challenges that require advanced solutions to 
+maintain a competitive edge. 
+From managing vast amounts of unstructured data to delivering personalized customer experiences, businesses need 
+efficient tools to tackle these obstacles. 
+Machine learning (ML) has emerged as a powerful tool for automating repetitive tasks, processing data effectively, and 
+generating valuable insights from multimedia content. 
+Jina AI's Inference offers a comprehensive solution to streamline access to curated, state-of-the-art ML models, 
+eliminating traditional roadblocks such as costly and time-consuming MLOps steps and the distinction between public and 
+custom neural network models.
+
+## Getting started
+
+To access the fastest and most performant CLIP models, [Jina AI's Inference](https://cloud.jina.ai/user/inference) is 
+the go-to choice. 
+Follow the steps below to get started:
+
+1. Sign up for a free account at [Jina AI Cloud](https://cloud.jina.ai).
+2. Once you have created an account, navigate to the Inference tab to create a new CLIP model.
+3. The model can be accessed either through an HTTP endpoint or a gRPC endpoint.
+
+## Obtaining a Personal Access Token
+
+Before you begin using [Jina AI's Inference](https://cloud.jina.ai/user/inference), ensure that you have obtained a 
+personal access token (PAT) from the [Jina AI Cloud](https://cloud.jina.ai) or through the command-line interface (CLI). 
+Use the following guide to create a new PAT:
+
+1. Access the [Jina AI Cloud](https://cloud.jina.ai) and log in to your account.
+2. Navigate to the [**Access token**](https://cloud.jina.ai/settings/tokens) section in the **Settings** tab, or alternatively, create a PAT via the CLI using the command:
+
+```bash
+jina auth token create <name of PAT> -e <expiration days>
+```
+
+## Installing the Inference Client
+
+To interact with the model created in Inference, you will need to install the `inference-client` Python package. 
+Follow the steps below to install the package using pip:
+
+```bash
+pip install inference-client
+```
+
+## Interacting with the Model
+
+Once you have your personal access token and the model name listed in the Inference detail page, you can start 
+interacting with the model using the `inference-client` Python package. 
+Follow the example code snippet below:
+
+```python
+from inference_client import Client
+
+client = Client(token='<your auth token>')
+
+model = client.get_model('<your model name>')
+```
+
+The CLIP models offer the following functionalities:
+
+1. Encoding: Users can encode data by calling the `model.encode` method. For detailed instructions on using this method, refer to the [Encode documentation](https://jina.readme.io/docs/encode).
+2. Ranking: Users can perform ranking by calling the `model.rank` method. Refer to the [Rank documentation](https://jina.readme.io/docs/rank) for detailed instructions on using this method.
+
+For further details on usage and information about other tasks and models supported in Inference, as well as how to use 
+`curl` to interact with the model, please consult the [Inference documentation](https://jina.readme.io/docs/inference).

clip_as_service/docs/hosting/colab.md

@@ -0,0 +1,37 @@
+# Host on Google Colab
+
+```{figure} https://clip-as-service.jina.ai/_images/colab-banner.png
+:width: 0 %
+:scale: 0 %
+```
+
+```{figure} colab-banner.png
+:scale: 0 %
+:width: 0 %
+```
+
+
+As [Jina is fully compatible to Google Colab](https://docs.jina.ai/how-to/google-colab/), CLIP-as-service can be run smoothly on Colab as well. One can host `clip_server` on Google Colab by leveraging its free GPU/TPU resources and open up to 4 replicas of `ViT-L/14-336px`. Then you can send request from local to the server for embedding, ranking and reasoning tasks. 
+
+Specifically, the architecture is illustrated below:
+
+```{figure} cas-on-colab.svg
+:width: 70%
+```
+
+```{button-link} https://colab.research.google.com/github/jina-ai/clip-as-service/blob/main/docs/hosting/cas-on-colab.ipynb
+:color: primary
+:align: center
+
+{octicon}`link-external` Open the notebook on Google Colab 
+```
+
+Please follow the walk-through there. Enjoy the free GPU/TPU to build your awesome Jina applications!
+
+
+```{tip}
+Hosing service on Google Colab is not recommended if you server aims to be long-live or permanent. It is often used for quick experiment, demonstration or leveraging its free GPU/TPU. For stable, please deploy the CLIP model on your own server.
+```
+
+
+

clip_as_service/docs/hosting/on-jcloud.md

@@ -0,0 +1,78 @@
+# Host on JCloud
+
+Essentially `clip_server` is a Jina [Flow](https://docs.jina.ai/fundamentals/flow/). Any Jina Flow can be hosted on [JCloud](https://docs.jina.ai/fundamentals/jcloud/), hence `clip_server` can be hosted on JCloud as well. Learn more about [JCloud here](https://docs.jina.ai/fundamentals/jcloud/).
+
+
+First, you need a Flow YAML file for deploy. A minimum YAML file is as follows:
+
+````{tab} torch-flow.yml
+
+```yaml
+jtype: Flow
+executors:
+  - uses: jinahub+docker://CLIPTorchEncoder
+```
+
+````
+````{tab} onnx-flow.yml
+
+```yaml
+jtype: Flow
+executors:
+  - uses: jinahub+docker://CLIPOnnxEncoder
+```
+
+````
+
+```{tip}
+`port` is unnecessary here as JCloud will assign a new hostname and port for any deployed service. 
+```
+
+Executors must start with `jinahub+docker://` as it is required by JCloud. We currently provide containerized executors [`jinahub+docker://CLIPTorchEncoder`](https://cloud.jina.ai/executor/gzpbl8jh) and [`jinahub+docker://CLIPOnnxEncoder`](https://cloud.jina.ai/executor/2a7auwg2) on Jina Hub. They are automatically synced on the new release of `clip_server` module. 
+
+To enable GPU on JCloud, you need to configure it in the YAML file and use prebuilt docker GPU images. For example,
+
+```yaml
+jtype: Flow
+executors:
+  - uses: jinahub+docker://CLIPTorchEncoder/latest-gpu
+    jcloud:
+      resources:
+        gpu: shared
+```
+
+Please refer [here](https://docs.jina.ai/fundamentals/jcloud/yaml-spec/#gpu) for more details on using GPU in JCloud.
+Notice that you must specify a docker image GPU tag for your executor to utilize the GPU. For example `latest-gpu`. 
+See the 'Tag' section in [CLIPTorchEncoder](https://cloud.jina.ai/executor/gzpbl8jh) and [CLIPOnnxEncoder](https://cloud.jina.ai/executor/2a7auwg2) for docker image GPU tags.
+
+To deploy,
+
+````{tab} PyTorch-backed
+```bash
+jc deploy torch-flow.yml
+```
+````
+
+````{tab} ONNX-backed
+```bash
+jc deploy onnx-flow.yml
+```
+````
+
+
+If Flow is successfully deployed you will see:
+
+```{figure} jc-deploy.png
+:width: 60%
+```
+
+You can now connect to it via client by setting  `server` as the URL given by JCloud:
+
+```python
+from clip_client import Client
+
+c = Client(
+    'grpcs://174eb69ba3.wolf.jina.ai'
+)  # This is the URL you get from previous step
+c.profile()
+```

clip_as_service/docs/html_extra/robots.txt

@@ -0,0 +1,2 @@
+User-agent: *
+sitemap: https://clip-as-service.jina.ai/sitemap.xml

clip_as_service/docs/index.md

@@ -0,0 +1,176 @@
+# Welcome to CLIP-as-service!
+
+
+```{include} ../README.md
+:start-after: <!-- start elevator-pitch -->
+:end-before: <!-- end elevator-pitch -->
+```
+
+## Try it!
+
+## Install
+
+![PyPI](https://img.shields.io/pypi/v/clip_client?color=%23ffffff&label=%20) is the latest version.
+
+Make sure you are using Python 3.7+. You can install the client and server independently. It is **not required** to install both: e.g. you can install `clip_server` on a GPU machine and `clip_client` on a local laptop.
+
+````{tab} Client
+
+```bash
+pip install clip-client
+```
+
+````
+
+````{tab} Server (PyTorch)
+
+```bash
+pip install clip-server
+```
+````
+
+````{tab} Server (ONNX)
+
+```bash
+pip install "clip_server[onnx]"
+```
+
+````
+
+
+````{tab} Server (TensorRT)
+
+```bash
+pip install nvidia-pyindex 
+pip install "clip_server[tensorrt]"
+```
+````
+
+````{tab} Server on Google Colab
+
+```{button-link} https://colab.research.google.com/github/jina-ai/clip-as-service/blob/main/docs/hosting/cas-on-colab.ipynb
+:color: primary
+:align: center
+
+{octicon}`link-external` Open the notebook on Google Colab 
+```
+
+````
+
+
+## Quick check
+
+After installing, you can run the following commands for a quick connectivity check.
+
+### Start the server
+
+````{tab} Start PyTorch Server 
+```bash
+python -m clip_server
+```
+````
+
+````{tab} Start ONNX Server 
+```bash
+python -m clip_server onnx-flow.yml
+```
+````
+
+````{tab} Start TensorRT Server 
+```bash
+python -m clip_server tensorrt-flow.yml
+```
+````
+
+At the first time starting the server, it will download the default pretrained model, which may take a while depending on your network speed. Then you will get the address information similar to the following: 
+
+```text
+╭────────────── 🔗 Endpoint ───────────────╮
+│  🔗     Protocol                   GRPC  │
+│  🏠        Local          0.0.0.0:51000  │
+│  🔒      Private    192.168.31.62:51000  │
+|  🌍       Public   87.105.159.191:51000  |
+╰──────────────────────────────────────────╯  
+```
+
+This means the server is ready to serve. Note down the three addresses shown above, you will need them later.
+
+### Connect from client
+
+```{tip}
+Depending on the location of the client and server. You may use different IP addresses:
+- Client and server are on the same machine: use local address, e.g. `0.0.0.0`
+- Client and server are connected to the same router: use private network address, e.g. `192.168.3.62`
+- Server is in public network: use public network address, e.g. `87.105.159.191`
+```
+
+Run the following Python script:
+
+```python
+from clip_client import Client
+
+c = Client('grpc://0.0.0.0:51000')
+c.profile()
+```
+
+will give you:
+
+```text
+ Roundtrip  16ms  100%
+├──  Client-server network  8ms  49%
+└──  Server  8ms  51%
+    ├──  Gateway-CLIP network  2ms  25%
+    └──  CLIP model  6ms  75%
+{'Roundtrip': 15.684750003856607, 'Client-server network': 7.684750003856607, 'Server': 8, 'Gateway-CLIP network': 2, 'CLIP model': 6}
+```
+
+It means the client and the server are now connected. Well done!
+
+
+```{include} ../README.md
+:start-after: <!-- start support-pitch -->
+:end-before: <!-- end support-pitch -->
+```
+
+
+```{toctree}
+:caption: User Guides
+:hidden:
+
+user-guides/client
+user-guides/server
+user-guides/benchmark
+user-guides/retriever
+user-guides/faq
+```
+
+```{toctree}
+:caption: Hosting
+:hidden:
+
+
+hosting/colab
+```
+
+```{toctree}
+:caption: Playground
+:hidden:
+
+playground/embedding
+playground/reasoning
+playground/searching
+```
+
+
+```{toctree}
+:caption: Developer References
+:hidden:
+:maxdepth: 1
+
+api/clip_client
+```
+
+
+---
+{ref}`genindex` | {ref}`modindex`
+

clip_as_service/docs/makedoc.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+set -ex
+
+rm -rf api && make clean
+
+make dirhtml

clip_as_service/docs/playground/embedding.md

@@ -0,0 +1,16 @@
+# Text & Image Embedding
+
+Embedding is a basic task in CLIP-as-service. It means converting your input sentence or image into a fixed-length vector. In this demo, you can choose a picture, input a sentence in the textbox, or copy-paste your image URL into the text box to get a rough feeling how CLIP-as-service works.
+
+This is *not* a search task. The images are random stock images and are related to any search results, they are mainly for saving your time on finding some random internet cat pictures. 
+
+The model is `ViT-L/14-336px` on one GPU.
+
+<iframe frameborder="0" allowtransparency="true" scrolling="no" src="../../_static/demo-embed.html" style="overflow:hidden;overflow-x:hidden;overflow-y:hidden;height:100vh;width:100%"></iframe>
+
+```{button-link} ../../_static/demo-embed.html
+:color: primary
+:align: center
+
+{octicon}`link-external` Open this playground in a new window
+```