{% trans %}Back to top{% endtrans %}
{% block content %}{{ body }}{% endblock %}
-brightgreen?style=flat-square&logo=googlecolab&&logoColor=white){kind=icon}
| via HTTPS 🔐 | via gRPC 🔐⚡⚡ |
|
```bash
curl \
-X POST https:// |
```python
# pip install clip-client
from clip_client import Client
c = Client(
'grpcs:// |
| Image | via HTTPS 🔐 |
|
|
```bash
curl \
-X POST https:// |
|
|
```bash
curl \
-X POST https:// |
|
|
```bash
curl \
-X POST https:// |
| Pytorch Runtime ⚡ | ONNX Runtime ⚡⚡ | TensorRT Runtime ⚡⚡⚡ |
| ```bash pip install clip-server ``` | ```bash pip install "clip-server[onnx]" ``` | ```bash pip install nvidia-pyindex pip install "clip-server[tensorrt]" ``` |
| C/S | Command | Expect output |
|---|---|---|
| Server | ```bash python -m clip_server ``` |
|
| Client | ```python from clip_client import Client c = Client('grpc://0.0.0.0:23456') c.profile() ``` |
|
| "a happy potato" | "a super evil AI" | "a guy enjoying his burger" |
|---|---|---|
|
|
|
|
| "professor cat is very serious" | "an ego engineer lives with parent" | "there will be no tomorrow so lets eat unhealthy" |
|---|---|---|
|
|
|
|
|
|
|
|
|
|
| Besides, there was truth in his looks | Gardiner smiled | what’s his name | By tea time, however, the dose had been enough, and Mr | You do not look well |
|
|
|
|
|
|
| “A gamester!” she cried | If you mention my name at the Bell, you will be attended to | Never mind Miss Lizzy’s hair | Elizabeth will soon be the wife of Mr | I saw them the night before last |
|
|
| Input a sentence (or an image URL) | |
| Click an image to select |
|
| Upload image from local |
Done in {{elapsed}}ms
{{query}}
| Input an image URL | |
| Click an image to select |
|
| Upload image from local |
Done in {{elapsed}}ms
{{query}}
Showing reasoning results (score in softmax):
| {{item.text}} | {{(item.scores['clip_score'].value * 100).toFixed(2)}} |
{%- endblock %}
================================================
FILE: docs/_templates/sidebar/brand.html
================================================
{% block brand_content %}
{%- if logo_url %}
Oops, we couldn't find that page.
You can try "asking our docs" on the right corner of the page to find answer.
Otherwise, please create a Github issue and one of our team will respond.
''', } 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 = [ '', '', '', '', '', ''' ''', ] 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',), ), ], ) ================================================ FILE: docs/hosting/by-jina.md ================================================ # Hosted by Jina AI ```{include} ../../README.md :start-after: :end-before: ``` 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
|
| high quality leather construction defines a hearty boot one-piece on a tough lug sole | [https://n.nordstrommedia.com/id/sr3/
|
| this shimmering tricot knit tote is traced with decorative whipstitching and diamond cut chain the two hallmark of the falabella line | [https://n.nordstrommedia.com/id/sr3/
|
| ... | ... | ... |
You can use the following script to transform the first three entries of the dataset to a {class}`~docarray.array.document.DocumentArray` and push it to the cloud using the name `fashion-sample`.
```python
from docarray import Document, DocumentArray
train_da = DocumentArray(
[
Document(
chunks=[
Document(
content='subtly futuristic and edgy this liquid metal cuff bracelet is shaped from sculptural rectangular link',
modality='text',
),
Document(
uri='https://n.nordstrommedia.com/id/sr3/58d1a13f-b6b6-4e68-b2ff-3a3af47c422e.jpeg',
modality='image',
),
],
),
Document(
chunks=[
Document(
content='high quality leather construction defines a hearty boot one-piece on a tough lug sole',
modality='text',
),
Document(
uri='https://n.nordstrommedia.com/id/sr3/21e7a67c-0a54-4d09-a4a4-6a0e0840540b.jpeg',
modality='image',
),
],
),
Document(
chunks=[
Document(
content='this shimmering tricot knit tote is traced with decorative whipstitching and diamond cut chain the two hallmark of the falabella line',
modality='text',
),
Document(
uri='https://n.nordstrommedia.com/id/sr3/1d8dd635-6342-444d-a1d3-4f91a9cf222b.jpeg',
modality='image',
),
],
),
]
)
train_da.push('fashion-sample')
```
The full dataset has been converted to `clip-fashion-train-data` and `clip-fashion-eval-data` and pushed to the cloud which can be directly used in Finetuner.
## Start Finetuner
You may now create and run a fine-tuning job after login to Jina ecosystem.
```python
import finetuner
finetuner.login()
run = finetuner.fit(
model='ViT-B-32::openai',
run_name='clip-fashion',
train_data='clip-fashion-train-data',
eval_data='clip-fashion-eval-data', # optional
epochs=5,
learning_rate=1e-5,
loss='CLIPLoss',
to_onnx=True,
)
```
After the job started, you may use {meth}`~finetuner.run.Run.status` to check the status of the job.
```python
import finetuner
finetuner.login()
run = finetuner.get_run('clip-fashion')
print(run.status())
```
When the status is `FINISHED`, you can download the tuned model to your local machine.
```python
import finetuner
finetuner.login()
run = finetuner.get_run('clip-fashion')
run.save_artifact('clip-model')
```
You should now get a zip file containing the tuned model named `clip-fashion.zip` under the folder `clip-model`.
## Use the Model
After unzipping the model you get from the previous step, a folder with the following structure will be generated:
```text
.
└── clip-fashion/
├── config.yml
├── metadata.yml
├── metrics.yml
└── models/
├── clip-text/
│ ├── metadata.yml
│ └── model.onnx
├── clip-vision/
│ ├── metadata.yml
│ └── model.onnx
└── input-map.yml
```
Since the tuned model generated from Finetuner contains richer information such as metadata and config, we now transform it to simpler structure used by CLIP-as-service.
* Firstly, create a new folder named `clip-fashion-cas` or name of your choice. This will be the storage of the models to use in CLIP-as-service.
* Secondly, copy the textual model `clip-fashion/models/clip-text/model.onnx` into the folder `clip-fashion-cas` and rename the model to `textual.onnx`.
* Similarly, copy the visual model `clip-fashion/models/clip-vision/model.onnx` into the folder `clip-fashion-cas` and rename the model to `visual.onnx`.
This is the expected structure of `clip-fashion-cas`:
```text
.
└── clip-fashion-cas/
├── textual.onnx
└── visual.onnx
```
In order to use the fine-tuned model, create a custom YAML file `finetuned_clip.yml` like below. Learn more about [Flow YAML configuration](https://docs.jina.ai/fundamentals/flow/yaml-spec/) and [`clip_server` YAML configuration](https://clip-as-service.jina.ai/user-guides/server/#yaml-config).
```yaml
jtype: Flow
version: '1'
with:
port: 51000
executors:
- name: clip_o
uses:
jtype: CLIPEncoder
metas:
py_modules:
- clip_server.executors.clip_onnx
with:
name: ViT-B-32::openai
model_path: 'clip-fashion-cas' # path to clip-fashion-cas
replicas: 1
```
You can use `finetuner.describe_models()` to check the supported models in `finetuner`, you should see:
```bash
Finetuner backbones
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ name ┃ task ┃ output_dim ┃ architecture ┃ description ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ bert-base-cased │ text-to-text │ 768 │ transformer │ BERT model pre-trained on BookCorpus and English Wikipedia │
│ openai/clip-vit-base-patch16 │ text-to-image │ 512 │ transformer │ CLIP base model with patch size 16 │
│ openai/clip-vit-base-patch32 │ text-to-image │ 512 │ transformer │ CLIP base model │
│ openai/clip-vit-large-patch14-336 │ text-to-image │ 768 │ transformer │ CLIP large model for 336x336 images │
│ openai/clip-vit-large-patch14 │ text-to-image │ 1024 │ transformer │ CLIP large model with patch size 14 │
│ efficientnet_b0 │ image-to-image │ 1280 │ cnn │ EfficientNet B0 pre-trained on ImageNet │
│ efficientnet_b4 │ image-to-image │ 1792 │ cnn │ EfficientNet B4 pre-trained on ImageNet │
│ RN101::openai │ text-to-image │ 512 │ transformer │ Open CLIP "RN101::openai" model │
│ RN101-quickgelu::openai │ text-to-image │ 512 │ transformer │ Open CLIP "RN101-quickgelu::openai" model │
│ RN101-quickgelu::yfcc15m │ text-to-image │ 512 │ transformer │ Open CLIP "RN101-quickgelu::yfcc15m" model │
│ RN101::yfcc15m │ text-to-image │ 512 │ transformer │ Open CLIP "RN101::yfcc15m" model │
│ RN50::cc12m │ text-to-image │ 1024 │ transformer │ Open CLIP "RN50::cc12m" model │
│ RN50::openai │ text-to-image │ 1024 │ transformer │ Open CLIP "RN50::openai" model │
│ RN50-quickgelu::cc12m │ text-to-image │ 1024 │ transformer │ Open CLIP "RN50-quickgelu::cc12m" model │
│ RN50-quickgelu::openai │ text-to-image │ 1024 │ transformer │ Open CLIP "RN50-quickgelu::openai" model │
│ RN50-quickgelu::yfcc15m │ text-to-image │ 1024 │ transformer │ Open CLIP "RN50-quickgelu::yfcc15m" model │
│ RN50x16::openai │ text-to-image │ 768 │ transformer │ Open CLIP "RN50x16::openai" model │
│ RN50x4::openai │ text-to-image │ 640 │ transformer │ Open CLIP "RN50x4::openai" model │
│ RN50x64::openai │ text-to-image │ 1024 │ transformer │ Open CLIP "RN50x64::openai" model │
│ RN50::yfcc15m │ text-to-image │ 1024 │ transformer │ Open CLIP "RN50::yfcc15m" model │
│ ViT-B-16::laion400m_e31 │ text-to-image │ 512 │ transformer │ Open CLIP "ViT-B-16::laion400m_e31" model │
│ ViT-B-16::laion400m_e32 │ text-to-image │ 512 │ transformer │ Open CLIP "ViT-B-16::laion400m_e32" model │
│ ViT-B-16::openai │ text-to-image │ 512 │ transformer │ Open CLIP "ViT-B-16::openai" model │
│ ViT-B-16-plus-240::laion400m_e31 │ text-to-image │ 640 │ transformer │ Open CLIP "ViT-B-16-plus-240::laion400m_e31" model │
│ ViT-B-16-plus-240::laion400m_e32 │ text-to-image │ 640 │ transformer │ Open CLIP "ViT-B-16-plus-240::laion400m_e32" model │
│ ViT-B-32::laion2b_e16 │ text-to-image │ 512 │ transformer │ Open CLIP "ViT-B-32::laion2b_e16" model │
│ ViT-B-32::laion400m_e31 │ text-to-image │ 512 │ transformer │ Open CLIP "ViT-B-32::laion400m_e31" model │
│ ViT-B-32::laion400m_e32 │ text-to-image │ 512 │ transformer │ Open CLIP "ViT-B-32::laion400m_e32" model │
│ ViT-B-32::openai │ text-to-image │ 512 │ transformer │ Open CLIP "ViT-B-32::openai" model │
│ ViT-B-32-quickgelu::laion400m_e31 │ text-to-image │ 512 │ transformer │ Open CLIP "ViT-B-32-quickgelu::laion400m_e31" model │
│ ViT-B-32-quickgelu::laion400m_e32 │ text-to-image │ 512 │ transformer │ Open CLIP "ViT-B-32-quickgelu::laion400m_e32" model │
│ ViT-B-32-quickgelu::openai │ text-to-image │ 512 │ transformer │ Open CLIP "ViT-B-32-quickgelu::openai" model │
│ ViT-L-14-336::openai │ text-to-image │ 768 │ transformer │ Open CLIP "ViT-L-14-336::openai" model │
│ ViT-L-14::openai │ text-to-image │ 768 │ transformer │ Open CLIP "ViT-L-14::openai" model │
│ resnet152 │ image-to-image │ 2048 │ cnn │ ResNet152 pre-trained on ImageNet │
│ resnet50 │ image-to-image │ 2048 │ cnn │ ResNet50 pre-trained on ImageNet │
│ sentence-transformers/msmarco-distilbert-base-v3 │ text-to-text │ 768 │ transformer │ Pretrained BERT, fine-tuned on MS Marco │
└──────────────────────────────────────────────────┴────────────────┴────────────┴──────────────┴───────────────────────────────────────────────────────────
```
You can now start the `clip_server` using fine-tuned model to get a performance boost:
```bash
python -m clip_server finetuned_clip.yml
```
That's it, enjoy 🚀
================================================
FILE: docs/user-guides/retriever.md
================================================
# CLIP Search
CLIP Search is a search paradigm that uses the CLIP model to encode the text and image documents into a common vector space.
The search results are then retrieved by computing the cosine similarity between the query and the indexed documents.
Technically, CLIP search can be designed as a two-stage process: *encoding* and *indexing*.
```{figure} images/retreival.png
:width: 80%
```
At the encoding stage, the text and image documents can be encoded into a common vector space by the CLIP model.
It enables us to achieve cross-modal search, i.e., we can search for images given a text query, or search for text given an image query.
At the indexing stage, we use the encoded vectors to build an index, which is a data structure that can be used to efficiently retrieve the most relevant documents.
Specifically, we use the [Annlite](https://github.com/jina-ai/annlite) indexer executor to build the index.
This chapter will walk you through the process of building a CLIP search system.
```{tip}
You will need to install server first in Python 3.7+: `pip install clip-server[search]>=0.7.0`.
```
## Start the server
To start the server, you can use the following command:
```bash
python -m clip_server search_flow.yml
```
The `search_flow.yml` is the yaml configuration file for the search flow. It defines a [Jina Flow](https://docs.jina.ai/fundamentals/flow/) to implement the CLIP search system.
Below is an example of the Flow YAML file, we can put it into two subsections as below:
````{tab} CLIP model config
```{code-block} yaml
---
emphasize-lines: 9
---
jtype: Flow
version: '1'
with:
port: 61000
executors:
- name: encoder
uses:
jtype: CLIPEncoder
metas:
py_modules:
- clip_server.executors.clip_torch
- name: indexer
uses:
jtype: AnnLiteIndexer
with:
n_dim: 512
metas:
py_modules:
- annlite.executor
workspace: './workspace'
```
````
````{tab} Annlite indexer config
```{code-block} yaml
---
emphasize-lines: 17,18,19
---
jtype: Flow
version: '1'
with:
port: 61000
executors:
- name: encoder
uses:
jtype: CLIPEncoder
with:
metas:
py_modules:
- clip_server.executors.clip_torch
- name: indexer
uses:
jtype: AnnLiteIndexer
with:
n_dim: 512
limit: 10
metas:
py_modules:
- annlite.executor
workspace: './workspace'
```
````
The first part defines the CLIP model config, which is explained [here](https://clip-as-service.jina.ai/user-guides/server/#clip-model-config).
And the second part defines the Annlite indexer config, you can set the following parameters:
| Parameter | Description |
|-----------|----------------------------------------------------------------------------------------------|
| `n_dim` | The dimension of the vector space. It should be the same as the dimension of the CLIP model. |
| `limit` | The number of the most relevant documents to be retrieved. The default value is 10. |
And the `workspace` parameter is the path to the workspace directory, which is used to store the index files.
## Index and search documents
```{tip}
You will need to install client first in Python 3.7+: `pip install clip-client>=0.7.0`.
```
### Index Documents
To index image or text documents in the CLIP search server, you can use the client function {func}`~clip_client.Client.index`:
```python
from clip_client import Client
from docarray import Document
client = Client('grpc://0.0.0.0:61000')
client.index(
[
Document(text='she smiled, with pain'),
Document(uri='apple.png'),
Document(uri='https://clip-as-service.jina.ai/_static/favicon.png'),
]
)
```
You don't need to call `client.encode()` explicitly since `client.index()` will handle this for you.
### Search Documents
Then, you can use the client function {func}`~clip_client.Client.search` to search for similar documents:
```python
result = client.search(['smile'], limit=2)
print(result['@m', ['text', 'scores__cosine']])
```
The results will look like this, the most relevant doc is "she smiled, with pain" with the cosine distance of 0.096. And the apple image has the cosine distance of 0.799.
```text
[['she smiled, with pain', ''], [{'value': 0.09604918956756592}, {'value': 0.7994111776351929}]]
```
You can set the `limit` parameter (default is `10`) to control the number of the most similar documents to be retrieved.
### Memory Estimation
Here, we will show how to estimate the memory usage of `AnnLite` indexer.
This is useful for determining the amount of memory required for indexing and querying.
In `AnnLite`, the memory usage is determined by the following two components:
- `HNSW` indexer: N * 1.1 * (4 bytes * `dimension` + 8 bytes * `max_connection`), where N is the number of embedding vectors, `dimension` is the dimension of the embedding vectors, and `max_connection` is the maximum number of connections in the graph.
- `cell_table`: it's almost linear to the number of columns and number of data. If the default setting is used (no columns used for filtering), the memory usage of `cell_table` is 0.12GB per million data.
Columns used for filtering are stored in string type so the memory usage is depended on the length of the string.
```{Notice}
If you use `AnnLiteIndexer` in your Jina Flow, the memory usage will be slightly higher since we keep a `SQLite` table in memory in order to indexing in `DocumentArray`.
```
## Support large-scale dataset
When we want to index a large number of documents, for example, 100 million data or even 1 billion data,
it's not possible to implement index operations on a single machine. **Sharding**,
a type of partitioning that separates a large dataset into smaller, faster, more easily managed parts, is needed in this case.
You need to specify the `shards` and `polling` in the YAML config:
```yaml
jtype: Flow
version: '1'
with:
port: 61000
executors:
- name: encoder
uses:
jtype: CLIPEncoder
metas:
py_modules:
- clip_server.executors.clip_torch
- name: indexer
uses:
jtype: AnnLiteIndexer
with:
n_dim: 512
metas:
py_modules:
- annlite.executor
workspace: './workspace'
shards: 5
polling: {'/index': 'ANY', '/search': 'ALL', '/update': 'ALL',
'/delete': 'ALL', '/status': 'ALL'}
```
| Parameter | Description |
|-------------|---------------------------------------------|
| `shards` | Number of shardings. |
| `polling` | Polling strategies for different endpoints. |
Then you can perform exactly the same operations as we do on a single machine.(`/encode`, `/index` and `/search`)
**Why different [polling strategies](https://docs.jina.ai/how-to/scale-out/?highlight=polling#different-polling-strategies) are needed for different endpoints?**
Differences between `ANY` and `ALL`:
- `ANY`: requests are sent to one of the executors.
- `ALL`: requests are sent to all executors.
```{figure} images/polling_stratey.png
:width: 80%
```
Since one data point only needs to be indexed once, there will only be one indexer executor that will handle this data point. Thus, `ANY` is used for `/index`. On the contrary, we use `ALL` in for `/search` since we don't know which executor stores the perfectly matched result, so the search request should be handled by all indexer executors. (The same reason for using `ALL` in `/update`, `/delete`, `/status`)
```{Warning}
Increasing the number of shardings will definitely alleviate the memory issue, but it will increase the latency since there will be more network connections between different shards.
```
================================================
FILE: docs/user-guides/server.md
================================================
# Server API
CLIP-as-service is designed in a client-server architecture. A server is a long-running program that receives raw sentences and images from clients, and returns CLIP embeddings to the client. Additionally, `clip_server` is optimized for speed, low memory footprint and scalability.
- Horizontal scaling: adding more replicas easily with one argument.
- Vertical scaling: using PyTorch JIT, ONNX or TensorRT runtime to speedup single GPU inference.
- Supporting gRPC, HTTP, Websocket protocols with their TLS counterparts, w/o compressions.
This chapter introduces the API of the server.
```{tip}
You will need to install server first in Python 3.7+: `pip install clip-server`.
```
(server-address)=
## Start server
### Start a PyTorch-backed server
Unlike the client, server only has a CLI entrypoint. To start a server, run the following in the terminal:
```bash
python -m clip_server
```
Note that it is underscore `_` not the dash `-`.
First time running will download the pretrained model (Pytorch `ViT-B/32` by default), load the model, and finally you will get the address information of the server. This information will {ref}`then be used in clients }})
 }})
Jina }})
 }})
Jina Hub }})
 }})
Finetuner }})
 }})
DocArray }})
 }})
CLIP-as-service }})
 }})
JCloud }})
 }})
NOW