# Configuring Embedding Providers for Semantic Search in CRG: 5 Supported Backends

> Explore CRG's five embedding providers for semantic search: Local, Gemini, MiniMax, OpenAI compatible, and Voyage AI. Configure easily with parameters or environment variables.

- Repository: [Tirth Kanani/code-review-graph](https://github.com/tirth8205/code-review-graph)
- Tags: how-to-guide
- Published: 2026-08-08

---

**Code-Review-Graph supports five embedding providers—Local (sentence-transformers), Google Gemini, MiniMax, OpenAI-compatible, and Voyage AI—selected via the `get_provider()` factory function in [`embeddings.py`](https://github.com/tirth8205/code-review-graph/blob/main/embeddings.py) using either explicit parameters or environment variables.**

The `tirth8205/code-review-graph` repository enables semantic code search by vectorizing graph nodes through a pluggable embedding pipeline. Configuring embedding providers for semantic search in CRG involves selecting a backend via the `EmbeddingProvider` interface and setting the required environment variables for cloud-based services.

## Available Embedding Providers

The embedding subsystem is defined in [`code_review_graph/embeddings.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/embeddings.py), which declares the abstract `EmbeddingProvider` interface and five concrete implementations. Valid provider identifiers are stored in the `_VALID_PROVIDERS` set at line 69.

### Local Sentence-Transformers Provider

The `LocalEmbeddingProvider` class runs embeddings entirely on-premises using the `sentence-transformers` library. It is the default when no provider is specified. Set `CRG_EMBEDDING_MODEL` to override the default `all-MiniLM-L6-v2` model (defined as `LOCAL_DEFAULT_MODEL` at line 68).

### Google Gemini Provider

The `GoogleEmbeddingProvider` class interfaces with Google's embedding API. Activation requires `provider="google"` and the `GOOGLE_API_KEY` environment variable. The model defaults to `"gemini-embedding-001"` if not explicitly provided.

### MiniMax Provider

The `MiniMaxEmbeddingProvider` targets the MiniMax `embo-01` embedding model. Specify `provider="minimax"` and export `MINIMAX_API_KEY` to authenticate requests.

### OpenAI-Compatible Provider

The `OpenAIEmbeddingProvider` supports any OpenAI-compatible endpoint, including custom local servers. It requires three environment variables: `CRG_OPENAI_API_KEY`, `CRG_OPENAI_BASE_URL`, and `CRG_OPENAI_MODEL`. Optional tuning parameters include `CRG_OPENAI_DIMENSION` and `CRG_OPENAI_BATCH_SIZE`.

### Voyage AI Provider

The `VoyageEmbeddingProvider` connects to Voyage AI's embedding service. It requires `VOYAGE_API_KEY` and accepts optional configuration via `CRG_VOYAGE_BASE_URL`, `CRG_VOYAGE_MODEL`, `CRG_VOYAGE_DIMENSION`, `CRG_VOYAGE_DTYPE`, `CRG_VOYAGE_BATCH_SIZE`, and rate-limit controls.

## Provider Selection Logic

The `get_provider()` function (lines 72-119) serves as the factory for provider instantiation. It normalizes the provider name to lowercase, validates it against `_VALID_PROVIDERS`, and implements fallback logic: if no provider is specified but `CRG_OPENAI_API_KEY` and `CRG_OPENAI_BASE_URL` exist, it automatically selects the OpenAI provider.

```python
def get_provider(provider: str | None = None, model: str | None = None) -> EmbeddingProvider | None:
    # Normalise the name

    name = provider.strip().lower() if provider else ""
    # Validate

    if name and name not in _VALID_PROVIDERS:
        raise ValueError(...)
    # Implicit OpenAI when env vars are present

    if provider is None and os.environ.get("CRG_OPENAI_API_KEY") and os.environ.get("CRG_OPENAI_BASE_URL"):
        name = "openai"
    # Dispatch to the concrete class …

```

## Cloud Egress Warnings

When a cloud provider is selected and the target URL is not localhost, CRG invokes `_warn_cloud_egress` (lines 443-466) to print a security warning about sending code snippets to external APIs. Suppress this warning by setting `CRG_ACCEPT_CLOUD_EMBEDDINGS=1`.

## Provider Identity and Vector Re-embedding

Each provider exposes a `name` property encoding the backend configuration (e.g., `openai:text-embedding-3-small@https://api.openai.com`). This identifier is persisted in the SQLite `embeddings` table. The `EmbeddingStore.embed_nodes` method (lines 100-119) compares this stored name against the current provider; a mismatch triggers automatic re-embedding of affected nodes to ensure vector consistency.

## Practical Configuration Examples

Use the default local provider without any environment variables:

```python
from code_review_graph.embeddings import EmbeddingStore, get_provider

store = EmbeddingStore(db_path="my_graph.db")           # provider defaults to "local"

print(store.provider.name)                             # → "local:all-MiniLM-L6-v2"

```

Switch to OpenAI embeddings via environment variables:

```python
import os
os.environ["CRG_OPENAI_API_KEY"] = "sk-…"
os.environ["CRG_OPENAI_BASE_URL"] = "https://api.openai.com/v1"
os.environ["CRG_OPENAI_MODEL"] = "text-embedding-3-small"

store = EmbeddingStore(db_path="my_graph.db", provider="openai")
print(store.provider.name)   # → "openai:text-embedding-3-small@https://api.openai.com"

```

Explicitly request the MiniMax provider:

```python
import os
os.environ["MINIMAX_API_KEY"] = "your‑minimax‑key"

store = EmbeddingStore(db_path="my_graph.db", provider="minimax")
print(store.provider.name)   # → "minimax:embo-01"

```

Perform a semantic search using the configured provider:

```python
results = store.search(query="how to authenticate a request", limit=5)
for qname, score in results:
    print(f"{qname}: {score:.4f}")

```

## Summary

- CRG abstracts embedding generation behind the `EmbeddingProvider` interface in [`code_review_graph/embeddings.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/embeddings.py).
- Five backends are supported: Local, Google Gemini, MiniMax, OpenAI-compatible, and Voyage AI.
- Select providers via `get_provider()` using explicit arguments or environment-driven defaults.
- Cloud providers trigger security warnings unless `CRG_ACCEPT_CLOUD_EMBEDDINGS=1` is set.
- Provider identity tracking ensures automatic re-embedding when backend configurations change.

## Frequently Asked Questions

### How do I switch from local to OpenAI embeddings in CRG?

Set the three required environment variables (`CRG_OPENAI_API_KEY`, `CRG_OPENAI_BASE_URL`, `CRG_OPENAI_MODEL`) and pass `provider="openai"` to `EmbeddingStore`, or rely on the implicit selection when these variables exist and no provider is specified. The `get_provider()` function automatically detects the OpenAI configuration when both the API key and base URL are present.

### What happens if I change the embedding model or provider after creating the graph?

CRG detects the change via the provider `name` property stored in the database and automatically triggers re-embedding of nodes through the `embed_nodes` logic (lines 100-119), ensuring search results use consistent vectors and preventing stale embeddings from mixing with new ones.

### Is it safe to use cloud embedding providers with proprietary code?

By default, CRG warns when sending data to non-localhost URLs via `_warn_cloud_egress` (lines 443-466). You must explicitly set `CRG_ACCEPT_CLOUD_EMBEDDINGS=1` to acknowledge the risk of code egress before proceeding with cloud-based providers such as Google, MiniMax, OpenAI, or Voyage.

### Which provider should I use for offline or air-gapped environments?

Use the `LocalEmbeddingProvider` (default) with `provider="local"` or no configuration, which runs `sentence-transformers` locally and requires no API keys or external network access. Set `CRG_EMBEDDING_MODEL` to specify a different local model if needed.