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

# Meta Generative AI with Weaviate

> [!NOTE]
>
> **Added in `v1.39.3`**

Weaviate's integration with [Meta's API](https://dev.meta.ai/docs/api-reference) allows you to access their generative models' capabilities directly from Weaviate.

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

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

![RAG integration illustration](https://docs.weaviate.io/assets/images/integration_meta_rag-3ca8bd3b6e92ccea919c55363d266251.png)

> [!NOTE]
>
> **Python client support is not released yet**
>
> Python client support for Meta is coming in an upcoming `weaviate-client` release. The snippets below do not run with the current client release.

## Requirements

### Weaviate configuration

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

`generative-meta` is an API-based module. Weaviate enables API-based modules by default, so the module is present on any `v1.39.3` or later instance that has not disabled them.

Check the [cluster metadata](https://docs.weaviate.io/deploy/configuration/status#cluster-metadata) to confirm that the module is enabled on your instance.

**For self-hosted users**

- Follow the [how-to configure modules](https://docs.weaviate.io/weaviate/configuration/modules) guide to enable the module in Weaviate.
- If you set [`API_BASED_MODULES_DISABLED`](https://docs.weaviate.io/deploy/configuration/env-vars#API_BASED_MODULES_DISABLED) to `true`, or you maintain your own [`ENABLE_MODULES`](https://docs.weaviate.io/deploy/configuration/env-vars#ENABLE_MODULES) list, add `generative-meta` to `ENABLE_MODULES`.

### API credentials

You must provide a valid Meta API key to Weaviate for this integration. See the [Meta API documentation](https://dev.meta.ai/docs/api-reference) to obtain an API key.

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

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

**Python**

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

# Recommended: save sensitive data as environment variables
meta_key = os.getenv("META_APIKEY")
headers = {
    "X-Meta-Api-Key": meta_key,
    # "X-Meta-Baseurl": "https://api.meta.ai",  # 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.

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

**Python**

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

client.collections.create(
    "DemoCollection",
    generative_config=Configure.Generative.meta()
    # Additional parameters not shown
)
```

### Select a model

Name the model in the collection configuration:

**Python**

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

client.collections.create(
    "DemoCollection",
    generative_config=Configure.Generative.meta(
        model="muse-spark-1.2"
    )
    # Additional parameters not shown
)
```

See [Available models](https://docs.weaviate.io/weaviate/model-providers/meta/generative#available-models) for the names you can use and for the default. You can also [override the model at query time](https://docs.weaviate.io/weaviate/model-providers/meta/generative#select-a-model-at-runtime).

### Generative parameters

Configure the following generative parameters to customize the model behavior.

**Python**

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

client.collections.create(
    "DemoCollection",
    generative_config=Configure.Generative.meta(
        # # These parameters are optional
        # model="muse-spark-1.2",
        # temperature=0.7,  # 0.0 to 2.0
        # top_p=0.9,  # 0.0 to 1.0
        # max_tokens=500,  # 1 or higher; no upper limit
        # frequency_penalty=0.0,  # -2.0 to 2.0
        # presence_penalty=0.0,  # -2.0 to 2.0
        # reasoning_effort="low",  # One of "none", "minimal", "low", "medium", "high", "xhigh"
        # base_url="https://api.meta.ai",
    )
)
```

Weaviate has no default for `temperature`, `topP`, `maxTokens`, `frequencyPenalty`, `presencePenalty`, or `reasoningEffort`: any one you leave unset is omitted from the request, so Meta's own default applies.

For further details on model parameters, see the [Meta API documentation](https://dev.meta.ai/docs/api-reference).

## Select a model at runtime

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

**Python**

```py
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.meta(
        model="muse-spark-1.2",
        # # These parameters are optional
        # temperature=0.7,
        # top_p=0.9,
        # max_tokens=500,
        # frequency_penalty=0.0,
        # presence_penalty=0.0,
        # reasoning_effort="low",
        # base_url="https://api.meta.ai",
    ),
    # 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-Meta-Api-Key`: The Meta API key.
- `X-Meta-Baseurl`: The base URL to use (e.g. a proxy) instead of the default Meta URL.

`X-Meta-Api-Key` overrides `META_APIKEY`, and a request with neither fails with an `api key` error.

`X-Meta-Baseurl` overrides any `baseURL` setting (default `https://api.meta.ai`) and must be an API root, because Weaviate appends `/v1/chat/completions`.

Provide the headers as shown in the [API credentials examples](https://docs.weaviate.io/weaviate/model-providers/meta/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/meta/generative#single-prompt) or [grouped task](https://docs.weaviate.io/weaviate/model-providers/meta/generative#grouped-task) method.

### Single prompt

![Single prompt RAG integration generates individual outputs per search result](https://docs.weaviate.io/assets/images/integration_meta_rag_single-645525744ff5779e181d33b3cbd931de.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.

**Python**

```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_meta_rag_grouped-e4daba9ee942a95409d589d09b632298.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.

**Python**

```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"])
```

### RAG with images

You can also supply images as a part of the input when performing retrieval augmented generation in both single prompts and grouped tasks.

**Python**

```py
import base64
import requests
from weaviate.classes.generate import GenerativeConfig, GenerativeParameters

src_img_path = "https://upload.wikimedia.org/wikipedia/commons/thumb/b/b0/Winter_forest_silver.jpg/960px-Winter_forest_silver.jpg"
base64_image = base64.b64encode(requests.get(src_img_path).content).decode('utf-8')

prompt = GenerativeParameters.grouped_task(
    prompt="Which movie is closest to the image in terms of atmosphere",
    images=[base64_image],      # A list of base64 encoded strings of the image bytes
    # image_properties=["img"], # Properties containing images in Weaviate
)

collection = client.collections.use("DemoCollection")
response = collection.generate.near_text(
    query="Movies",
    limit=5,
    grouped_task=prompt,
    generative_provider=GenerativeConfig.meta(
        max_tokens=1000
    ),
)

# Print the source property and the generated response
for o in response.objects:
    print(f"Title property: {o.properties['title']}")
print(f"Grouped task result: {response.generative.text}")
```

## References

### Available models

Weaviate passes the model name through unchecked. See [Meta's documentation](https://dev.meta.ai/docs/api-reference) for the current models.

If you do not set a model, Weaviate uses `muse-spark-1.2`.

If long generations time out, raise [`MODULES_CLIENT_TIMEOUT`](https://docs.weaviate.io/deploy/configuration/env-vars#MODULES_CLIENT_TIMEOUT).

## 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

- [Meta API documentation](https://dev.meta.ai/docs/api-reference)
