# Text Embeddings (custom)

Weaviate's integration with the Hugging Face Transformers library allows you to access their models' capabilities directly from Weaviate.

Configure a Weaviate vector index to use the Transformers integration, and [configure the Weaviate instance](#configure-the-weaviate-instance) with a model image, and Weaviate will generate embeddings for various operations using the specified model in the Transformers inference container. This feature is called the _vectorizer_.

This page shows how to [build a custom Transformers model image](#build-a-custom-transformers-model-image) and configure Weaviate with it, for users whose desired model is not available in [the pre-built images](transformers-embeddings.md#available-models).

Once a custom image is built and configured, usage patterns are identical to the pre-built images.

## Build a custom Transformers model image

You can build a custom Transformers model image to use with Weaviate. This can be a public model from the Hugging Face model hub, or a compatible private or local model.

Embedding (also called 'feature extraction') models from the [Hugging Face model hub](https://huggingface.co/models) can be used with Weaviate by building a custom Docker image.

The steps to build a custom image are:

- [Create a `Dockerfile` that downloads the model](#create-a-dockerfile).
- [Build and tag the Dockerfile](#build-and-tag-the-dockerfile).
- [Use the image in your Weaviate instance](#use-the-image).

#### Create a `Dockerfile`

The `Dockerfile` to create depends on whether you are using a public model from the Hugging Face model hub, or a private or local model.

::::tabs{sync="deployments"}
:::tab{title="Public model"}
This example creates a custom image for the [`distilroberta-base` model](https://huggingface.co/distilbert/distilroberta-base). Replace `distilroberta-base` with the model name you want to use.

To build an image with a model from the Hugging Face Hub, create a new `Dockerfile` similar to the following.

Save the `Dockerfile` as `my-inference-image.Dockerfile`. (You can name it anything you like.)

```yaml
FROM semitechnologies/transformers-inference:custom
RUN MODEL_NAME=distilroberta-base ./download.py
```
:::

:::tab{title="Private/local model"}
You can also build a custom image with any model that is compatible with the Transformer library's `AutoModel` and `AutoTokenizer` classes.

To build an image with a local, custom model, create a new `Dockerfile` similar to the following, replacing `./my-model` with the path to your model folder.

Save the `Dockerfile` as `my-inference-image.Dockerfile`. (You can name it anything you like.)

This will create a custom image for a model stored in a local folder `my-model` on your machine.

```yaml
FROM semitechnologies/transformers-inference:custom
COPY ./my-model /app/models/model
```

Do not modify `/app/models/model`, as this is the path where the application expects to find the model.
:::
::::

#### Build and tag the Dockerfile.

Tag the Dockerfile with a name, for example `my-inference-image`:

```shell
docker build -f my-inference-image.Dockerfile -t my-inference-image .
```

#### (Optional) Push the image to a registry

If you want to use the image in a different environment, you can push it to a Docker registry:

```shell
docker push my-inference-image
```

#### Use the image

[Specify the image in your Weaviate configuration](transformers-embeddings.md#weaviate-configuration), such as in `docker-compose.yml`, using the chosen local Docker tag (e.g. `my-inference-image`), or the image from the registry.

#### (Optional) Use the `sentence-transformers` vectorizer

:::callout{intent="warning" title="Experimental feature"}
This is an experimental feature. Use with caution.
:::

When using a custom image, you may set the `USE_SENTENCE_TRANSFORMERS_VECTORIZER` environment variable to use the [`sentence-transformers` vectorizer](https://sbert.net/) instead of the default vectorizer from the `transformers` library.

## Configure the Weaviate instance

Once you have built and configured the custom Transformers model image, continue on to the [Transformers embeddings integrations](transformers-embeddings.md) guide to use the model with Weaviate.

Following the above example, set the `image` parameter in the `text2vec-transformers` service as the name of the custom image, e.g. `my-inference-image`.

## (Optional) Test the inference container

Once the inference container is configured and running, you can send queries it directly to test its functionality.

First, expose the inference container. If deployed using Docker, forward the port by adding the following to the `text2vec-transformers` service in your `docker-compose.yml`:

```yaml
services:
  weaviate:
    # Additional settings not shown
  text2vec-transformers:
    # Additional settings not shown
    ports:
      - "9090:8080"  # Add this line to expose the container
```

Once the container is running and exposed, you can send REST requests to it directly, e.g.:

```shell
curl localhost:9090/vectors -H 'Content-Type: application/json' -d '{"text": "foo bar"}'
```

If the container is running and configured correctly, you should receive a response with the vector embedding of the input text.

### External resources

- Hugging Face [Model Hub](https://huggingface.co/models)

## Questions and feedback

Have a question or feedback? Here's how to reach us.

::::card-grid
:::card{title="Community Forum" href="https://forum.weaviate.io/c/support" icon="messages-square"}
Ask questions and connect with other developers on our **Community forum**.
:::

:::card{title="Support" href="/guides/support-overview" icon="life-buoy"}
Weaviate Cloud user or customer? Find the right channel on the **Support page**.
:::
::::

## Related pages

- [Agents](./agents-index.md)
- [AI-assisted Weaviate code generation](./ai-assisted-vibe-coding-index.md)
- [APIs](./apis-index.md)
- [Authorization and authentication](./authorization-and-authentication-index.md)
- [Benchmarks](./benchmarks-index.md)
- [Best practices](./best-practices-index.md)
- [Client libraries](./clients-index.md)
- [Client Libraries / SDKs](./client-libraries-index.md)
- [Cloud](./cloud-index.md)
- [Cloud account management](./cloud-account-management-index.md)

# Agent Instructions

This portal answers questions programmatically. To receive a synthesized,
source-cited answer instead of crawling page by page, append the `?ask=`
query parameter to any page URL on this site:

    /guides/quickstart?ask=how+do+I+authenticate

Optional parameters:

- `&goal=<what-you-are-trying-to-do>` steers the answer toward your
  objective (e.g. `&goal=write+a+python+client`).
- `&version=<label>` scopes the answer to a mounted version when the
  portal publishes more than one.

The response is `text/markdown`: the answer followed by a `# Sources` list
of the portal pages it was grounded in. Status codes are the contract:

- `200` — the answer; `402` — the portal owner’s plan or answer credits are
  exhausted (surface this to your operator; do NOT retry); `429` — you are
  rate-limited; back off for the `Retry-After` seconds; `503` — the answer
  lane is temporarily unavailable; fall back to crawling the `.md` pages.

For the full corpus map read `llms.txt` at the site root; for the tool
surface (search + page fetch as MCP tools) see `/mcp`.
