# Vector Store Backends Supported by semantica.vector_store: FAISS, Qdrant, Weaviate, Pinecone & pgvector

> Explore semantica.vector_store backends like FAISS Qdrant Weaviate Pinecone & pgvector. Easily integrate your preferred vector database with our unified interface.

- Repository: [Semantica /semantica](https://github.com/semantica-agi/semantica)
- Tags: api-reference
- Published: 2026-08-21

---

**The `semantica.vector_store` module supports eight distinct backends—FAISS, Qdrant, Weaviate, Pinecone, pgvector, Milvus, in-memory, and SQLite—each accessible through a unified `VectorStore` interface that validates against the `SUPPORTED_BACKENDS` constant.**

The `semantica-agi/semantica` repository provides a pluggable vector storage layer via the `semantica.vector_store` package. Whether you require a local embedding index for development or a managed cloud service for production, the library dynamically instantiates the correct concrete implementation based on the backend name you provide.

## Complete List of Supported Backends

The canonical allowlist of backends is defined in [`semantica/vector_store/vector_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/vector_store.py) at lines 12-13:

```python
SUPPORTED_BACKENDS = {
    "faiss", "weaviate", "qdrant", "milvus",
    "pinecone", "pgvector", "inmemory", "sqlite"
}

```

When you call `VectorStore(backend="...")`, the constructor validates your string against this set. If valid, the internal `_init_backend_store` method instantiates the corresponding concrete store class (e.g., `FAISSStore`, `QdrantStore`). Each implementation resides in its own module and exposes a common API for vector operations.

### FAISS (Local Vector Index)

- **Module**: [`semantica/vector_store/faiss_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/faiss_store.py)
- **Class**: `FAISSStore`
- **Characteristics**: Local, pure-Python vector index supporting flat, IVF, HNSW, and PQ index types. Requires no external services.

### Qdrant (Remote Vector Database)

- **Module**: [`semantica/vector_store/qdrant_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/qdrant_store.py)
- **Class**: `QdrantStore`
- **Characteristics**: Remote vector database with collection-based organization, payload filtering, and REST/gRPC interfaces.

### Weaviate (Graph-Aware Search)

- **Module**: [`semantica/vector_store/weaviate_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/weaviate_store.py)
- **Class**: `WeaviateStore`
- **Characteristics**: Cloud or on-premise deployment with graph-aware capabilities and hybrid search (vector + BM25).

### Pinecone (Managed SaaS)

- **Module**: [`semantica/vector_store/pinecone_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/pinecone_store.py)
- **Class**: `PineconeStore`
- **Characteristics**: Fully managed SaaS vector database offering namespace isolation, metadata filtering, and auto-scaling.

### pgvector (PostgreSQL Extension)

- **Module**: [`semantica/vector_store/pgvector_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/pgvector_store.py)
- **Class**: `PgVectorStore`
- **Characteristics**: Leverages the PostgreSQL pgvector extension for ACID-compliant vector storage with SQL-based filtering and indexing.

### Additional Backends

Beyond the five primary backends asked about, `semantica.vector_store` also supports:

- **Milvus**: [`semantica/vector_store/milvus_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/milvus_store.py) (`MilvusStore`) — Distributed vector database with GPU acceleration capabilities.
- **In-memory**: [`semantica/vector_store/vector_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/vector_store.py) — Lightweight Python dictionary implementation for rapid prototyping and testing.
- **SQLite**: [`semantica/vector_store/sqlite_vec_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/sqlite_vec_store.py) (`SQLiteVectorStore`) — Persistent local storage using SQLite with vector extensions.

## How to Instantiate Each Backend

The following examples demonstrate minimal configuration for the five queried backends. All examples assume you have installed the specific third-party client libraries (e.g., `faiss-cpu`, `qdrant-client`, `weaviate-client`, `pinecone-client`, `psycopg2`).

### FAISS (Local, No External Service)

```python
from semantica.vector_store import VectorStore

faiss_store = VectorStore(backend="faiss", config={"dimension": 384})
faiss_store.store_vectors([[0.1, 0.2, 0.3]], [{"title": "doc1"}])
print(faiss_store.search_vectors([0.1, 0.2, 0.3], k=5))

```

### Qdrant (Remote Service)

```python
from semantica.vector_store import VectorStore

qdrant_store = VectorStore(
    backend="qdrant",
    config={"url": "http://localhost:6333", "collection_name": "my-collection", "dimension": 384}
)
qdrant_store.store_vectors([[0.1, 0.2, 0.3]], [{"title": "doc1"}])
print(qdrant_store.search_vectors([0.1, 0.2, 0.3], k=5))

```

### Weaviate (Cloud or On-Premise)

```python
from semantica.vector_store import VectorStore

weaviate_store = VectorStore(
    backend="weaviate",
    config={"url": "http://localhost:8080", "class_name": "Document", "dimension": 384}
)
weaviate_store.store_vectors([[0.1, 0.2, 0.3]], [{"title": "doc1"}])
print(weaviate_store.search_vectors([0.1, 0.2, 0.3], k=5))

```

### Pinecone (Managed SaaS)

```python
from semantica.vector_store import VectorStore

pinecone_store = VectorStore(
    backend="pinecone",
    config={"api_key": "YOUR_API_KEY", "environment": "us-west1-gcp", "index_name": "my-index", "dimension": 384}
)
pinecone_store.store_vectors([[0.1, 0.2, 0.3]], [{"title": "doc1"}])
print(pinecone_store.search_vectors([0.1, 0.2, 0.3], k=5))

```

### pgvector (PostgreSQL Extension)

```python
from semantica.vector_store import VectorStore

pgvector_store = VectorStore(
    backend="pgvector",
    config={
        "connection_string": "postgresql://user:pass@localhost/db",
        "table_name": "vectors",
        "dimension": 384,
        "distance_metric": "cosine"
    }
)
pgvector_store.store_vectors([[0.1, 0.2, 0.3]], [{"title": "doc1"}])
print(pgvector_store.search_vectors([0.1, 0.2, 0.3], k=5))

```

## Architecture and Extensibility

Each concrete store implements a common interface exposing methods such as `add_vectors`, `search_vectors`, and `delete_vectors`. The high-level `VectorStore` class acts as a factory: it delegates all operations to the instantiated backend while providing a consistent Python API regardless of the underlying database.

To extend support for a new backend:

1. Create a new module in `semantica/vector_store/` (e.g., [`new_store.py`](https://github.com/semantica-agi/semantica/blob/main/new_store.py)).
2. Implement the required methods: `add_vectors`, `search_vectors`, `delete_vectors`, etc.
3. Add the backend identifier string to the `SUPPORTED_BACKENDS` set in [`semantica/vector_store/vector_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/vector_store.py).
4. Update the `_init_backend_store` method to import and instantiate your new class when the backend name is requested.

## Summary

- The `semantica.vector_store` module supports **eight backends**: FAISS, Qdrant, Weaviate, Pinecone, pgvector, Milvus, in-memory, and SQLite.
- Backend validation occurs against the `SUPPORTED_BACKENDS` constant defined in [`semantica/vector_store/vector_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/vector_store.py).
- Each backend resides in a dedicated module (e.g., [`faiss_store.py`](https://github.com/semantica-agi/semantica/blob/main/faiss_store.py), [`qdrant_store.py`](https://github.com/semantica-agi/semantica/blob/main/qdrant_store.py)) containing a specific implementation class (e.g., `FAISSStore`, `QdrantStore`).
- All backends expose unified methods for vector storage and retrieval, including `store_vectors` and `search_vectors`.
- Instantiation requires passing the backend name as a string and a configuration dictionary to the `VectorStore` constructor.

## Frequently Asked Questions

### Which vector store backend should I use for local development?

Use **FAISS** or the **in-memory** backend. FAISS provides high-performance local vector indexing without external dependencies, while the in-memory backend uses simple Python dictionaries for rapid prototyping. Both are defined in `SUPPORTED_BACKENDS` and require no network configuration.

### How do I check if a specific backend is available in my semantica installation?

Inspect the `SUPPORTED_BACKENDS` constant in [`semantica/vector_store/vector_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/vector_store.py). If the backend string exists in that set, the library supports it natively. You must also install the corresponding client library (e.g., `pip install faiss-cpu` or `pip install qdrant-client`) for the backend to function at runtime.

### Can I switch between vector backends without modifying my application logic?

Yes. The `VectorStore` class abstracts backend-specific details, so you can change the `backend` parameter and configuration dictionary without altering calls to `store_vectors()` or `search_vectors()`. The `_init_backend_store` method handles instantiation of the correct concrete class internally.

### Does semantica.vector_store support Milvus and SQLite in addition to the main five?

Yes. The `SUPPORTED_BACKENDS` set includes `"milvus"` for distributed GPU-accelerated vector search (module: [`milvus_store.py`](https://github.com/semantica-agi/semantica/blob/main/milvus_store.py)) and `"sqlite"` for persistent local storage using SQLite vector extensions (module: [`sqlite_vec_store.py`](https://github.com/semantica-agi/semantica/blob/main/sqlite_vec_store.py)). Both follow the same instantiation pattern as FAISS and Qdrant.