# Semantica Vector Store Backends: 7 Compatible Options Explained

> Explore seven vector store backends compatible with Semantica AGI including FAISS Milvus Qdrant Weaviate Pinecone PGVector and SQLite Learn how to easily swap between them

- Repository: [Semantica /semantica](https://github.com/semantica-agi/semantica)
- Tags: deep-dive
- Published: 2026-08-15

---

**Semantica supports seven built-in vector store backends: FAISS, Milvus, Qdrant, Weaviate, Pinecone, PGVector, and SQLite, each implementing a common `VectorStore` abstract base class for seamless swapping.**

The open-source Semantica framework uses a **plugin-based vector store architecture** that lets you switch between local and cloud-native vector databases without changing your application code. According to the `semantica-agi/semantica` source code, all backends live under `semantica/vector_store/` and share the same API contract defined in [`vector_store.py`](https://github.com/semantica-agi/semantica/blob/main/vector_store.py).

## Complete List of Semantica Vector Store Backends

The following table shows every compatible backend, its module location, and primary capabilities:

| Backend | Module | Primary Class | Best For |
|---------|--------|---------------|----------|
| **FAISS** | [`faiss_store.py`](https://github.com/semantica-agi/semantica/blob/main/faiss_store.py) | `FAISSStore` | Local, high-performance in-process search |
| **Milvus** | [`milvus_store.py`](https://github.com/semantica-agi/semantica/blob/main/milvus_store.py) | `MilvusStore` | Remote vector database with metadata filtering |
| **Qdrant** | [`qdrant_store.py`](https://github.com/semantica-agi/semantica/blob/main/qdrant_store.py) | `QdrantStore` | Cloud-native deployments with payload filtering |
| **Weaviate** | [`weaviate_store.py`](https://github.com/semantica-agi/semantica/blob/main/weaviate_store.py) | `WeaviateStore` | GraphQL-based hybrid search with schemas |
| **Pinecone** | [`pinecone_store.py`](https://github.com/semantica-agi/semantica/blob/main/pinecone_store.py) | `PineconeStore` | Managed SaaS with namespace isolation |
| **PGVector** | [`pgvector_store.py`](https://github.com/semantica-agi/semantica/blob/main/pgvector_store.py) | `PGVectorStore` | SQL-based retrieval in existing PostgreSQL |
| **SQLite** | [`sqlite_vec_store.py`](https://github.com/semantica-agi/semantica/blob/main/sqlite_vec_store.py) | `SQLiteVectorStore` | Prototyping and lightweight file-backed storage |

The [`registry.py`](https://github.com/semantica-agi/semantica/blob/main/registry.py) module makes these backends discoverable at runtime, enabling configuration-driven backend selection.

## Local and In-Process Backends

These **Semantica vector store backends** run entirely on your machine without external dependencies.

### FAISS (FAISSStore)

**FAISS** is Facebook AI's similarity search library, wrapped by `FAISSStore` in [`semantica/vector_store/faiss_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/faiss_store.py). It supports multiple index types and optional GPU acceleration.

Key features:
- Flat, IVF, HNSW, and Product Quantization indices
- GPU support for accelerated search
- Disk persistence for index saving/loading

```python
from semantica.vector_store import FAISSStore

faiss = FAISSStore(dimension=768)
faiss.create_index(index_type="hnsw", metric="L2")
ids = faiss.add_vectors(vectors=my_vectors, metadata=my_meta)
results = faiss.search_similar(query_vector=my_query, k=5)

```

### SQLite (SQLiteVectorStore)

**SQLiteVectorStore** in [`semantica/vector_store/sqlite_vec_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/sqlite_vec_store.py) provides a file-backed option for small workloads and rapid prototyping.

## Remote and Cloud-Native Backends

These backends connect to external vector database services.

### Milvus (MilvusStore)

**MilvusStore** in [`semantica/vector_store/milvus_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/milvus_store.py) wraps the Milvus remote vector database. It handles collections, partitions, and expression-based metadata filtering.

```python
from semantica.vector_store import MilvusStore

milvus = MilvusStore(host="localhost", port=19530)
milvus.connect()
milvus.create_collection("my_collection", dimension=768, metric_type="L2")
milvus.add_vectors(vectors=my_vectors, ids=my_ids, metadata=my_meta)
hits = milvus.search_vectors(
    query_vector=my_query, 
    limit=10, 
    expr="metadata['category'] == 'science'"
)

```

### Qdrant (QdrantStore)

**QdrantStore** in [`semantica/vector_store/qdrant_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/qdrant_store.py) integrates the Qdrant cloud-native vector database with HNSW and IVF index support plus payload filtering.

### Weaviate (WeaviateStore)

**WeaviateStore** in [`semantica/vector_store/weaviate_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/weaviate_store.py) enables schema-driven vector search with GraphQL-based metadata queries and hybrid search capabilities.

### Pinecone (PineconeStore)

**PineconeStore** in [`semantica/vector_store/pinecone_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/pinecone_store.py) connects to Pinecone's managed SaaS vector database, supporting namespaces, upserts, and metadata filtering.

### PGVector (PGVectorStore)

**PGVectorStore** in [`semantica/vector_store/pgvector_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/pgvector_store.py) leverages PostgreSQL with the pgvector extension for SQL-based vector retrieval in any Postgres-compatible database.

## Switching Backends via Configuration

The `vector_store_config` in [`semantica/vector_store/config.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/config.py) enables runtime backend switching without code changes:

```python
from semantica.vector_store.config import vector_store_config

vector_store_config.set("default_backend", "qdrant")

# Subsequent calls to VectorStore.from_config() instantiate QdrantStore automatically

```

This registry-based approach in [`registry.py`](https://github.com/semantica-agi/semantica/blob/main/registry.py) maps string names like `"faiss"`, `"milvus"`, or `"qdrant"` to their concrete implementations.

## Architecture Overview

All **Semantica vector store backends** inherit from the abstract base class `VectorStore` defined in [`semantica/vector_store/vector_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/vector_store/vector_store.py). This enforces consistent methods across implementations:

- `add_vectors()` — ingest vectors with optional metadata
- `search_similar()` / `search_vectors()` — retrieve nearest neighbors
- `create_index()` / `create_collection()` — initialize storage structures
- Persistence and connection management utilities

## Summary

- **Seven built-in backends**: FAISS, Milvus, Qdrant, Weaviate, Pinecone, PGVector, and SQLite
- **Common API**: All implement the `VectorStore` abstract base class in [`vector_store.py`](https://github.com/semantica-agi/semantica/blob/main/vector_store.py)
- **Runtime discovery**: The [`registry.py`](https://github.com/semantica-agi/semantica/blob/main/registry.py) module enables configuration-driven backend selection
- **Local options**: FAISS (high-performance) and SQLite (lightweight prototyping)
- **Cloud options**: Milvus, Qdrant, Weaviate, Pinecone, and PGVector for production deployments
- **Zero code changes**: Switch backends by modifying `vector_store_config` settings

## Frequently Asked Questions

### How do I choose between FAISS and a remote backend like Milvus or Qdrant?

**FAISS** suits single-machine deployments requiring maximum query throughput without network overhead. Choose **Milvus**, **Qdrant**, or **Pinecone** when you need horizontal scalability, multi-tenant isolation, or managed infrastructure. The `semantica-agi/semantica` source code implements identical APIs for both, so migration requires only configuration changes.

### Can I use multiple vector store backends simultaneously in one Semantica application?

Yes. Instantiate different store classes directly—`FAISSStore` for local caching alongside `PineconeStore` for persistent cloud storage—since each backend class is independent. The configuration-based `VectorStore.from_config()` singleton pattern targets one default backend, but direct instantiation bypasses this limitation.

### Does Semantica support custom vector store implementations beyond the built-in seven?

Yes. The `VectorStore` abstract base class in [`vector_store.py`](https://github.com/semantica-agi/semantica/blob/main/vector_store.py) defines the required interface. Implement `add_vectors()`, `search_similar()`, and persistence methods, then register your class in [`registry.py`](https://github.com/semantica-agi/semantica/blob/main/registry.py) to make it discoverable via `vector_store_config`.

### What metadata filtering capabilities vary across backends?

**Milvus** supports expression-based filtering with `expr` parameters. **Weaviate** uses GraphQL query syntax for complex metadata constraints. **Qdrant** and **Pinecone** offer payload and metadata key-value filtering. **FAISS** and **SQLite** store metadata but filter post-search in Python, which is less efficient for large datasets.