---
title: "DeepSeek Generative AI with Weaviate"
description: "Weaviate's integration with DeepSeek's API allows you to access their generative models' capabilities directly from Weaviate."
url: https://docs.weaviate.io/weaviate/model-providers/deepseek/generative
---

# DeepSeek Generative AI with Weaviate

Weaviate's integration with DeepSeek's API allows you to access their generative models' capabilities directly from Weaviate.

[Configure a Weaviate collection](https://docs.weaviate.io/weaviate/model-providers/deepseek/generative#configure-collection) to use a generative AI model with DeepSeek. Weaviate will perform retrieval augmented generation (RAG) using the specified model and your DeepSeek API key.

More specifically, Weaviate will perform a search, retrieve the most relevant objects, and then pass them to the DeepSeek generative model to generate outputs.

![RAG integration illustration](https://docs.weaviate.io/assets/images/integration_deepseek_rag-9b62a674a5a0eac0d59baf674b55ad06.png)

> [!NOTE]
>
> **Code examples are Python-only for now**
>
> Examples for the other client languages will follow.

## Requirements

### Weaviate configuration

Your Weaviate instance must be configured with the DeepSeek generative AI integration (`generative-deepseek`) module.

> [!NOTE]
>
> **Added in `v1.36.19`, `v1.37.10`, and `v1.38.2`**

**For Weaviate Cloud (WCD) users**

This integration is enabled by default on Weaviate Cloud (WCD) instances.

**For self-hosted users**

- Check the [cluster metadata](https://docs.weaviate.io/deploy/configuration/status#cluster-metadata) to verify if the module is enabled.
- Follow the [how-to configure modules](https://docs.weaviate.io/weaviate/configuration/modules) guide to enable the module in Weaviate.
- To enable the module, include it in the `ENABLE_MODULES` environment variable available to Weaviate, e.g. `ENABLE_MODULES="generative-deepseek"` (add it to your existing comma-separated list if other modules are enabled).

### API credentials

You must provide a valid DeepSeek API key to Weaviate for this integration. Go to [DeepSeek](https://platform.deepseek.com/) to sign up and obtain an API key.

Provide the API key to Weaviate using one of the following methods:

- Set the `DEEPSEEK_APIKEY` environment variable that is available to Weaviate.
- Provide the API key at runtime, as shown in the examples below.

```py
import weaviate
from weaviate.classes.init import Auth
import os

# Recommended: save sensitive data as environment variables
deepseek_key = os.getenv("DEEPSEEK_APIKEY")
headers = {
    "X-Deepseek-Api-Key": deepseek_key,
    # "X-Deepseek-Baseurl": "https://api.deepseek.com",  # Optional; for providing a custom base URL
}

client = weaviate.connect_to_weaviate_cloud(
    cluster_url=weaviate_url,                       # `weaviate_url`: your Weaviate URL
    auth_credentials=Auth.api_key(weaviate_key),      # `weaviate_key`: your Weaviate API key
    headers=headers
)

# Work with Weaviate

client.close()
```

## Configure collection

> [!NOTE]
>
> **Generative model integration mutability**
>
> A collection's `generative` model integration configuration is mutable from `v1.25.23`, `v1.26.8` and `v1.27.1`. See [this section](https://docs.weaviate.io/weaviate/manage-collections/generative-reranker-models#update-the-generative-model-integration) for details on how to update the collection configuration.

Always set `model` explicitly. The module's built-in default is a retired model alias, so a collection configured without a `model` points at a model that DeepSeek no longer serves. See [Available models](https://docs.weaviate.io/weaviate/model-providers/deepseek/generative#available-models) for the current model names.

[Configure a Weaviate index](https://docs.weaviate.io/weaviate/manage-collections/generative-reranker-models#specify-a-generative-model-integration) as follows to use a DeepSeek generative model:

```py
from weaviate.classes.config import Configure

client.collections.create(
    "DemoCollection",
    generative_config=Configure.Generative.deepseek(
        model="deepseek-v4-flash"
    )
    # Additional parameters not shown
)
```

### Select a model

Specify any current DeepSeek model name. See [Available models](https://docs.weaviate.io/weaviate/model-providers/deepseek/generative#available-models) for the current names, and [Generative parameters](https://docs.weaviate.io/weaviate/model-providers/deepseek/generative#generative-parameters) for the other settings you can configure alongside it.

You can also [override the model at query time](https://docs.weaviate.io/weaviate/model-providers/deepseek/generative#select-a-model-at-runtime).

### Generative parameters

Configure the following generative parameters to customize the model behavior.

```py
from weaviate.classes.config import Configure

client.collections.create(
    "DemoCollection",
    generative_config=Configure.Generative.deepseek(
        model="deepseek-v4-flash",
        # # These parameters are optional
        # temperature=0.7,
        # max_tokens=500,
        # frequency_penalty=0.0,
        # presence_penalty=0.0,
        # top_p=1.0,
        # base_url="https://api.deepseek.com",
        # stop=["\n\n"],
    )
)
```

Weaviate checks `maxTokens` against a built-in ceiling only for the retired `deepseek-chat` and `deepseek-reasoner` aliases. For any current model, a `maxTokens` above the model's limit is accepted when you create the collection and fails later, as an error from DeepSeek at query time.

For further details on model parameters, see the [DeepSeek API documentation](https://api-docs.deepseek.com/).

## Select a model at runtime

Aside from setting the default model provider when creating the collection, you can also override it at query time.

```py
from weaviate.classes.config import Configure
from weaviate.classes.generate import GenerativeConfig

collection = client.collections.use("DemoCollection")
response = collection.generate.near_text(
    query="A holiday film",
    limit=2,
    grouped_task="Write a tweet promoting these two movies",
    generative_provider=GenerativeConfig.deepseek(
        # # These parameters are optional
        model="deepseek-v4-pro",
        # temperature=0.7,
        # max_tokens=500,
        # frequency_penalty=0.0,
        # presence_penalty=0.0,
        # top_p=1.0,
        # base_url="https://api.deepseek.com",
        # stop=["\n\n"],
    ),
    # Additional parameters not shown
)
```

## Header parameters

You can provide the API key as well as some optional parameters at runtime through additional headers in the request. The following headers are available:

- `X-Deepseek-Api-Key`: The DeepSeek API key.
- `X-Deepseek-Baseurl`: The base URL to use (e.g. a proxy) instead of the default DeepSeek URL.

`X-Deepseek-Api-Key` takes precedence over the `DEEPSEEK_APIKEY` environment variable. The API key is never part of the collection configuration, so if neither the header nor the environment variable is set, the request fails with `api key: no api key found`.

`X-Deepseek-Baseurl` takes precedence over a `baseURL` set at query time, which in turn takes precedence over the `baseURL` in the collection configuration. If none of them are set, Weaviate uses `https://api.deepseek.com`. Provide an API root rather than a full endpoint path, because Weaviate appends `/chat/completions` to it.

Provide the headers as shown in the [API credentials examples](https://docs.weaviate.io/weaviate/model-providers/deepseek/generative#api-credentials) above.

## Retrieval augmented generation

After configuring the generative AI integration, perform RAG operations, either with the [single prompt](https://docs.weaviate.io/weaviate/model-providers/deepseek/generative#single-prompt) or [grouped task](https://docs.weaviate.io/weaviate/model-providers/deepseek/generative#grouped-task) method.

### Single prompt

![Single prompt RAG integration generates individual outputs per search result](https://docs.weaviate.io/assets/images/integration_deepseek_rag_single-f79a15d8dba0fea847d3d17f85730d8f.png)

To generate text for each object in the search results, use the single prompt method.

The example below generates outputs for each of the `n` search results, where `n` is specified by the `limit` parameter.

When creating a single prompt query, use braces `{}` to interpolate the object properties you want Weaviate to pass on to the language model. For example, to pass on the object's `title` property, include `{title}` in the query.

```py
collection = client.collections.use("DemoCollection")

response = collection.generate.near_text(
    query="A holiday film",  # The model provider integration will automatically vectorize the query
    single_prompt="Translate this into French: {title}",
    limit=2
)

for obj in response.objects:
    print(obj.properties["title"])
    print(f"Generated output: {obj.generated}")  # Note that the generated output is per object
```

### Grouped task

![Grouped task RAG integration generates one output for the set of search results](https://docs.weaviate.io/assets/images/integration_deepseek_rag_grouped-085fc37341f545d5a9cf6ce792a691c8.png)

To generate one text for the entire set of search results, use the grouped task method.

In other words, when you have `n` search results, the generative model generates one output for the entire group.

```py
collection = client.collections.use("DemoCollection")

response = collection.generate.near_text(
    query="A holiday film",  # The model provider integration will automatically vectorize the query
    grouped_task="Write a fun tweet to promote readers to check out these films.",
    limit=2
)

print(f"Generated output: {response.generative.text}")  # Note that the generated output is per query
for obj in response.objects:
    print(obj.properties["title"])
```

## References

### Available models

Weaviate forwards the configured model name to DeepSeek as-is. There is no allowlist on the Weaviate side, so any current DeepSeek model name is accepted.

The current model names are `deepseek-v4-flash` and `deepseek-v4-pro`. For the full list of models and pricing, see the [DeepSeek pricing page](https://api-docs.deepseek.com/quick_start/pricing) and the [DeepSeek API documentation](https://api-docs.deepseek.com/).

> [!WARNING]
>
> **The module default is a retired model**
>
> The `deepseek-chat` and `deepseek-reasoner` aliases are retired and DeepSeek no longer serves them. They previously pointed at `deepseek-v4-flash` in its non-thinking and thinking modes respectively.
>
> The built-in default model of the `generative-deepseek` module is still `deepseek-chat`, so a collection created without a `model` points at a retired alias. Set `model` on every collection you create.

### Reasoning models

The `generative-deepseek` module returns only the model's message content. If you use a reasoning model, its separate reasoning (chain-of-thought) output is not surfaced through the integration.

Reasoning models can take much longer to respond than non-reasoning models. Weaviate applies the [`MODULES_CLIENT_TIMEOUT`](https://docs.weaviate.io/deploy/configuration/env-vars#MODULES_CLIENT_TIMEOUT) environment variable to the whole request, including reading the response, and it defaults to 50 seconds. If reasoning queries time out, raise this value on your Weaviate instance.

## Further resources

### Code examples

Once the integration is configured at the collection, the data management and search operations in Weaviate work identically to any other collection. See the following model-agnostic examples:

- The [How-to: Manage collections](https://docs.weaviate.io/weaviate/manage-collections) and [How-to: Manage objects](https://docs.weaviate.io/weaviate/manage-objects) guides show how to perform data operations (i.e. create, read, update, delete collections and objects within them).
- The [How-to: Query & Search](https://docs.weaviate.io/weaviate/search) guides show how to perform search operations (i.e. vector, keyword, hybrid) as well as retrieval augmented generation.

### References

- [DeepSeek API documentation](https://api-docs.deepseek.com/)