| Vector Database | Retrieval | Indexing | V2 Support* |

|-----------------|-----------|----------|-------------|

| Pgvector | [x] | [ ] | [] |

| Elasticsearch | [x] | [x] | [] |

| Milvus | [x] | [x] | [x] |

| Faiss | [ ] | [ ] | [] |

| SQLite | [x] | [ ] | [] |

| Qdrant | [x] | [x] | [] |

*Note: V2 Support means the SDK supports retrieval of features along with vector embeddings from vector similarity search.

{% hint style="danger" %}

We will be deprecating the `retrieve_online_documents` method in the SDK in the future.

We recommend using the `retrieve_online_documents_v2` method instead, which offers easier vector index configuration

directly in the Feature View and the ability to retrieve standard features alongside your vector embeddings for richer context injection.

Long term we will collapse the two methods into one, but for now, we recommend using the `retrieve_online_documents_v2` method.

Beyond that, we will then have `retrieve_online_documents` and `retrieve_online_documents_v2` simply point to `get_online_features` for

backwards compatibility and the adopt industry standard naming conventions.

{% endhint %}

**Note**: Milvus implements the v2 `retrieve_online_documents_v2` method in the SDK. This will be the longer-term solution so that Data Scientists can easily enable vector similarity search by just flipping a flag.

- See the v0 [Rag Demo](https://github.com/feast-dev/feast-workshop/blob/rag/module_4_rag) for an example on how to use vector database using the `retrieve_online_documents` method (planning migration and deprecation (planning migration and deprecation).

- See the v1 [Milvus Quickstart](../../examples/rag/milvus-quickstart.ipynb) for a quickstart guide on how to use Feast with Milvus using the `retrieve_online_documents_v2` method.

project: local_rag

registry: data/registry.db

type: milvus

path: data/online_store.db

embedding_dim: 384

index_type: "IVF_FLAT"

entity_key_serialization_version: 3

auth:

type: no_auth

document_embeddings = FeatureView(

name="embedded_documents",

entities=[item, author],

Field(

name="vector",

dtype=Array(Float32),

# Look how easy it is to enable RAG!

vector_index=True,

vector_search_metric="COSINE",

),

Field(name="item_id", dtype=Int64),

Field(name="author_id", dtype=String),

Field(name="created_timestamp", dtype=UnixTimestamp),

Field(name="sentence_chunks", dtype=String),

Field(name="event_timestamp", dtype=UnixTimestamp),

source=rag_documents_source,

ttl=timedelta(hours=24),

Let's use the SDK to write a data frame of embeddings to the online store:

store.write_to_online_store(feature_view_name='city_embeddings', df=df)

During inference (e.g., during when a user submits a chat message) we need to embed the input text. This can be thought of as a feature transformation of the input data. In this example, we'll do this with a small Sentence Transformer from Hugging Face.

import torch

import torch.nn.functional as F

from feast import FeatureStore

from pymilvus import MilvusClient, DataType, FieldSchema

from example_repo import city_embeddings_feature_view, item

TOKENIZER = "sentence-transformers/all-MiniLM-L6-v2"

MODEL = "sentence-transformers/all-MiniLM-L6-v2"

def mean_pooling(model_output, attention_mask):

token_embeddings = model_output[

0

] # First element of model_output contains all token embeddings

input_mask_expanded = (

attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()

)

return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(

input_mask_expanded.sum(1), min=1e-9

)

def run_model(sentences, tokenizer, model):

encoded_input = tokenizer(

sentences, padding=True, truncation=True, return_tensors="pt"

)

# Compute token embeddings

with torch.no_grad():

model_output = model(**encoded_input)

sentence_embeddings = mean_pooling(model_output, encoded_input["attention_mask"])

sentence_embeddings = F.normalize(sentence_embeddings, p=2, dim=1)

return sentence_embeddings

question = "Which city has the largest population in New York?"

query_embedding = run_model(question, tokenizer, model).detach().cpu().numpy().tolist()[0]

First create a feature store instance, and use the `retrieve_online_documents_v2` API to retrieve the top 5 similar documents to the specified query.

context_data = store.retrieve_online_documents_v2(

features=[

"city_embeddings:vector",

"city_embeddings:item_id",

"city_embeddings:state",

"city_embeddings:sentence_chunks",

"city_embeddings:wiki_summary",

],

query=query_embedding,

top_k=3,

distance_metric='COSINE',

).to_df()

Let's assume we have a base prompt and a function that formats the retrieved documents called `format_documents` that we

can then use to generate the response with OpenAI's chat completion API.

```python

FULL_PROMPT = format_documents(rag_context_data, BASE_PROMPT)

client = OpenAI(

api_key=os.environ.get("OPENAI_API_KEY"),

)

response = client.chat.completions.create(

model="gpt-4o-mini",

messages=[

{"role": "system", "content": FULL_PROMPT},

{"role": "user", "content": question}

],

)

print('\n'.join([c.message.content for c in response.choices]))

We offer [Milvus](https://milvus.io/), [PGVector](https://github.com/pgvector/pgvector), [SQLite](https://github.com/asg017/sqlite-vec), [Elasticsearch](https://www.elastic.co) and [Qdrant](https://qdrant.tech/) as Online Store options for Vector Databases.

Milvus offers a convenient local implementation for vector similarity search. To use Milvus, you can install the Feast package with the Milvus extra.

pip install feast[milvus]

If you are using `pyenv` to manage your Python versions, you can install the SQLite extension with the following command:

PYTHON_CONFIGURE_OPTS="--enable-loadable-sqlite-extensions" \

LDFLAGS="-L/opt/homebrew/opt/sqlite/lib" \

CPPFLAGS="-I/opt/homebrew/opt/sqlite/include" \

pyenv install 3.10.14

And you can the Feast install package via:

pip install feast[sqlite_vec]