Semantica Vector Store Backends: 7 Compatible Options Explained

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.

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	FAISSStore	Local, high-performance in-process search
Milvus	milvus_store.py	MilvusStore	Remote vector database with metadata filtering
Qdrant	qdrant_store.py	QdrantStore	Cloud-native deployments with payload filtering
Weaviate	weaviate_store.py	WeaviateStore	GraphQL-based hybrid search with schemas
Pinecone	pinecone_store.py	PineconeStore	Managed SaaS with namespace isolation
PGVector	pgvector_store.py	PGVectorStore	SQL-based retrieval in existing PostgreSQL
SQLite	sqlite_vec_store.py	SQLiteVectorStore	Prototyping and lightweight file-backed storage

The 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. 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

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 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 wraps the Milvus remote vector database. It handles collections, partitions, and expression-based metadata filtering.

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 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 enables schema-driven vector search with GraphQL-based metadata queries and hybrid search capabilities.

Pinecone (PineconeStore)

PineconeStore in 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 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 enables runtime backend switching without code changes:

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 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. 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
• Runtime discovery: The 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 defines the required interface. Implement add_vectors(), search_similar(), and persistence methods, then register your class in 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}