Skip to content

API Reference

SeekMe SDK package.

Client

Unified client that composes DB, vector, and embedding components.

Source code in src/seekme/client.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
class Client:
    """Unified client that composes DB, vector, and embedding components."""

    def __init__(
        self,
        *,
        db: Database | None = None,
        vector_store: VectorStore | None = None,
        embedder: Embedder | None = None,
    ) -> None:
        self._db = db
        self._vector_store = vector_store
        self._embedder = embedder

    @classmethod
    def from_database_url(
        cls,
        url: str,
        *,
        db_driver: str = DEFAULT_DB_DRIVER,
        **driver_kwargs: Any,
    ) -> Client:
        """Create a client from a database URL using a registered driver."""

        ensure_defaults()
        factory = get_db_driver(db_driver)
        return cls(db=factory(url, **driver_kwargs))

    @property
    def db(self) -> Database | None:
        """Return the database component."""

        return self._db

    @property
    def vector_store(self) -> VectorStore | None:
        """Return the vector store component."""

        if self._vector_store is None and self._db is not None:
            ensure_defaults()
            factory = get_vector_store(DEFAULT_VECTOR_STORE)
            self._vector_store = factory(self._db, embedder=self._embedder)
        return self._vector_store

    @property
    def embedder(self) -> Embedder | None:
        """Return the embedding component."""

        return self._embedder

    def connect(self) -> Client:
        """Explicitly connect underlying components when supported."""

        if self._db is not None:
            self._db.connect()
        return self

    def close(self) -> None:
        """Close underlying components when supported."""

        if self._db is not None:
            self._db.close()

    def __enter__(self) -> Client:
        return self.connect()

    def __exit__(self, exc_type: type[BaseException] | None, exc: BaseException | None, tb: Any) -> None:
        self.close()

db property

Return the database component.

embedder property

Return the embedding component.

vector_store property

Return the vector store component.

close()

Close underlying components when supported.

Source code in src/seekme/client.py 
70
71
72
73
74
def close(self) -> None:
    """Close underlying components when supported."""

    if self._db is not None:
        self._db.close()

connect()

Explicitly connect underlying components when supported.

Source code in src/seekme/client.py 
63
64
65
66
67
68
def connect(self) -> Client:
    """Explicitly connect underlying components when supported."""

    if self._db is not None:
        self._db.connect()
    return self

from_database_url(url, *, db_driver=DEFAULT_DB_DRIVER, **driver_kwargs) classmethod

Create a client from a database URL using a registered driver.

Source code in src/seekme/client.py 
27
28
29
30
31
32
33
34
35
36
37
38
39
@classmethod
def from_database_url(
    cls,
    url: str,
    *,
    db_driver: str = DEFAULT_DB_DRIVER,
    **driver_kwargs: Any,
) -> Client:
    """Create a client from a database URL using a registered driver."""

    ensure_defaults()
    factory = get_db_driver(db_driver)
    return cls(db=factory(url, **driver_kwargs))

ConfigurationError

Bases: SeekMeError

Raised when configuration is invalid or incomplete.

Source code in src/seekme/exceptions.py 
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
class ConfigurationError(SeekMeError):
    """Raised when configuration is invalid or incomplete."""

    def __init__(self, message: str | None = None) -> None:
        super().__init__(message or "Configuration is invalid or incomplete.")

    @classmethod
    def extension_not_found(cls, kind: str, name: str) -> ConfigurationError:
        return cls(f"{kind} '{name}' is not registered.")

    @classmethod
    def database_driver_not_found(cls, name: str) -> ConfigurationError:
        return cls(f"Database driver '{name}' is not registered.")

    @classmethod
    def vector_store_not_found(cls, name: str) -> ConfigurationError:
        return cls(f"Vector store '{name}' is not registered.")

    @classmethod
    def embedder_not_found(cls, name: str) -> ConfigurationError:
        return cls(f"Embedder '{name}' is not registered.")

    @classmethod
    def invalid_extension_name(cls) -> ConfigurationError:
        return cls("Extension name must be non-empty.")

    @classmethod
    def embedding_not_configured(cls) -> ConfigurationError:
        return cls(
            "Embedding is not configured. Provide an embedder or install extras: "
            "pip install 'seekme[remote-embeddings]' or 'seekme[local-embeddings]'"
        )

    @classmethod
    def missing_optional_dependency(cls, extra: str) -> ConfigurationError:
        return cls(f"{extra} support requires extras: pip install 'seekme[{extra}]'")

DatabaseError

Bases: SeekMeError

Raised when database operations fail.

Source code in src/seekme/exceptions.py 
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
class DatabaseError(SeekMeError):
    """Raised when database operations fail."""

    def __init__(self, message: str | None = None) -> None:
        super().__init__(message or "Database operation failed.")

    @classmethod
    def connection_failed(cls) -> DatabaseError:
        return cls("Database connection failed.")

    @classmethod
    def execution_failed(cls) -> DatabaseError:
        return cls("SQL execution failed.")

    @classmethod
    def fetch_failed(cls) -> DatabaseError:
        return cls("SQL fetch failed.")

    @classmethod
    def transaction_failed(cls, action: str) -> DatabaseError:
        return cls(f"Transaction {action} failed.")

EmbeddingError

Bases: SeekMeError

Raised when embedding operations fail.

Source code in src/seekme/exceptions.py 
71
72
73
74
75
76
77
78
79
80
81
82
83
class EmbeddingError(SeekMeError):
    """Raised when embedding operations fail."""

    def __init__(self, message: str | None = None) -> None:
        super().__init__(message or "Embedding operation failed.")

    @classmethod
    def request_failed(cls) -> EmbeddingError:
        return cls("Embedding request failed.")

    @classmethod
    def response_failed(cls) -> EmbeddingError:
        return cls("Embedding response parsing failed.")

SeekMeError

Bases: Exception

Base error for the SDK.

Source code in src/seekme/exceptions.py 
6
7
class SeekMeError(Exception):
    """Base error for the SDK."""

ValidationError

Bases: ValueError, SeekMeError

Raised when user input fails validation.

Source code in src/seekme/exceptions.py 
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
class ValidationError(ValueError, SeekMeError):
    """Raised when user input fails validation."""

    def __init__(self, message: str) -> None:
        super().__init__(message)

    @classmethod
    def dimension_must_be_positive(cls) -> ValidationError:
        return cls("Dimension must be positive.")

    @classmethod
    def ids_vectors_mismatch(cls) -> ValidationError:
        return cls("Ids and vectors length mismatch.")

    @classmethod
    def metadatas_mismatch(cls) -> ValidationError:
        return cls("Metadatas length mismatch.")

    @classmethod
    def return_fields_empty(cls) -> ValidationError:
        return cls("Return fields must include at least one column.")

    @classmethod
    def embedding_empty(cls) -> ValidationError:
        return cls("Embedding result is empty.")

    @classmethod
    def invalid_identifier(cls, name: str) -> ValidationError:
        return cls(f"Invalid identifier: {name}")

    @classmethod
    def embedding_response_unsupported(cls) -> ValidationError:
        return cls("Unsupported embedding response format.")

    @classmethod
    def embedding_missing(cls) -> ValidationError:
        return cls("Embedding item missing embedding field.")

    @classmethod
    def invalid_filter_value(cls, name: str) -> ValidationError:
        return cls(f"Invalid filter value for '{name}'.")

    @classmethod
    def invalid_filter_key(cls, name: str) -> ValidationError:
        return cls(f"Invalid filter key: {name}")

    @classmethod
    def metadata_serialization_failed(cls) -> ValidationError:
        return cls("Metadata must be JSON serializable.")

    @classmethod
    def invalid_seekdb_url(cls, url: str) -> ValidationError:
        return cls(f"Invalid seekdb URL: {url}")

    @classmethod
    def seekdb_path_not_directory(cls, path: str) -> ValidationError:
        return cls(f"Seekdb path is not a directory: {path}")

    @classmethod
    def seekdb_already_opened(cls, path: str) -> ValidationError:
        return cls(f"Seekdb already opened at: {path}")

    @classmethod
    def unsupported_seekdb_options(cls, options: list[str]) -> ValidationError:
        return cls(f"Unsupported seekdb options: {options}")

    @classmethod
    def missing_sql_parameter(cls, name: str) -> ValidationError:
        return cls(f"Missing SQL parameter: {name}")

Unified SDK client entrypoint.

Client

Unified client that composes DB, vector, and embedding components.

Source code in src/seekme/client.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
class Client:
    """Unified client that composes DB, vector, and embedding components."""

    def __init__(
        self,
        *,
        db: Database | None = None,
        vector_store: VectorStore | None = None,
        embedder: Embedder | None = None,
    ) -> None:
        self._db = db
        self._vector_store = vector_store
        self._embedder = embedder

    @classmethod
    def from_database_url(
        cls,
        url: str,
        *,
        db_driver: str = DEFAULT_DB_DRIVER,
        **driver_kwargs: Any,
    ) -> Client:
        """Create a client from a database URL using a registered driver."""

        ensure_defaults()
        factory = get_db_driver(db_driver)
        return cls(db=factory(url, **driver_kwargs))

    @property
    def db(self) -> Database | None:
        """Return the database component."""

        return self._db

    @property
    def vector_store(self) -> VectorStore | None:
        """Return the vector store component."""

        if self._vector_store is None and self._db is not None:
            ensure_defaults()
            factory = get_vector_store(DEFAULT_VECTOR_STORE)
            self._vector_store = factory(self._db, embedder=self._embedder)
        return self._vector_store

    @property
    def embedder(self) -> Embedder | None:
        """Return the embedding component."""

        return self._embedder

    def connect(self) -> Client:
        """Explicitly connect underlying components when supported."""

        if self._db is not None:
            self._db.connect()
        return self

    def close(self) -> None:
        """Close underlying components when supported."""

        if self._db is not None:
            self._db.close()

    def __enter__(self) -> Client:
        return self.connect()

    def __exit__(self, exc_type: type[BaseException] | None, exc: BaseException | None, tb: Any) -> None:
        self.close()

db property

Return the database component.

embedder property

Return the embedding component.

vector_store property

Return the vector store component.

close()

Close underlying components when supported.

Source code in src/seekme/client.py 
70
71
72
73
74
def close(self) -> None:
    """Close underlying components when supported."""

    if self._db is not None:
        self._db.close()

connect()

Explicitly connect underlying components when supported.

Source code in src/seekme/client.py 
63
64
65
66
67
68
def connect(self) -> Client:
    """Explicitly connect underlying components when supported."""

    if self._db is not None:
        self._db.connect()
    return self

from_database_url(url, *, db_driver=DEFAULT_DB_DRIVER, **driver_kwargs) classmethod

Create a client from a database URL using a registered driver.

Source code in src/seekme/client.py 
27
28
29
30
31
32
33
34
35
36
37
38
39
@classmethod
def from_database_url(
    cls,
    url: str,
    *,
    db_driver: str = DEFAULT_DB_DRIVER,
    **driver_kwargs: Any,
) -> Client:
    """Create a client from a database URL using a registered driver."""

    ensure_defaults()
    factory = get_db_driver(db_driver)
    return cls(db=factory(url, **driver_kwargs))

Core database interfaces and primitives.

Database

Bases: ABC

Abstract database interface for executing SQL and managing transactions.

Source code in src/seekme/db/core.py 
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
class Database(ABC):
    """Abstract database interface for executing SQL and managing transactions."""

    @abstractmethod
    def connect(self) -> None:
        """Open the underlying connection."""

    @abstractmethod
    def close(self) -> None:
        """Close the underlying connection."""

    @abstractmethod
    def execute(self, sql: str, params: Mapping[str, Any] | None = None) -> int:
        """Execute a statement and return affected row count."""

    @abstractmethod
    def fetch_all(self, sql: str, params: Mapping[str, Any] | None = None) -> list[Mapping[str, Any]]:
        """Execute a query and return all rows."""

    @abstractmethod
    def fetch_one(self, sql: str, params: Mapping[str, Any] | None = None) -> Mapping[str, Any] | None:
        """Execute a query and return one row."""

    @abstractmethod
    def begin(self) -> None:
        """Begin a transaction."""

    @abstractmethod
    def commit(self) -> None:
        """Commit the current transaction."""

    @abstractmethod
    def rollback(self) -> None:
        """Rollback the current transaction."""

begin() abstractmethod

Begin a transaction.

Source code in src/seekme/db/core.py 
33
34
35
@abstractmethod
def begin(self) -> None:
    """Begin a transaction."""

close() abstractmethod

Close the underlying connection.

Source code in src/seekme/db/core.py 
17
18
19
@abstractmethod
def close(self) -> None:
    """Close the underlying connection."""

commit() abstractmethod

Commit the current transaction.

Source code in src/seekme/db/core.py 
37
38
39
@abstractmethod
def commit(self) -> None:
    """Commit the current transaction."""

connect() abstractmethod

Open the underlying connection.

Source code in src/seekme/db/core.py 
13
14
15
@abstractmethod
def connect(self) -> None:
    """Open the underlying connection."""

execute(sql, params=None) abstractmethod

Execute a statement and return affected row count.

Source code in src/seekme/db/core.py 
21
22
23
@abstractmethod
def execute(self, sql: str, params: Mapping[str, Any] | None = None) -> int:
    """Execute a statement and return affected row count."""

fetch_all(sql, params=None) abstractmethod

Execute a query and return all rows.

Source code in src/seekme/db/core.py 
25
26
27
@abstractmethod
def fetch_all(self, sql: str, params: Mapping[str, Any] | None = None) -> list[Mapping[str, Any]]:
    """Execute a query and return all rows."""

fetch_one(sql, params=None) abstractmethod

Execute a query and return one row.

Source code in src/seekme/db/core.py 
29
30
31
@abstractmethod
def fetch_one(self, sql: str, params: Mapping[str, Any] | None = None) -> Mapping[str, Any] | None:
    """Execute a query and return one row."""

rollback() abstractmethod

Rollback the current transaction.

Source code in src/seekme/db/core.py 
41
42
43
@abstractmethod
def rollback(self) -> None:
    """Rollback the current transaction."""

Vector storage interfaces.

VectorStore

Bases: ABC

Abstract vector store interface.

Source code in src/seekme/vector/core.py 
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
class VectorStore(ABC):
    """Abstract vector store interface."""

    @abstractmethod
    def create_collection(self, name: str, dimension: int) -> None:
        """Create a vector collection."""

    @abstractmethod
    def delete_collection(self, name: str) -> None:
        """Delete a vector collection."""

    @abstractmethod
    def upsert(
        self,
        collection: str,
        ids: Ids,
        vectors: Vectors,
        metadatas: Sequence[Mapping[str, Any]] | None = None,
    ) -> None:
        """Insert or update vectors."""

    @abstractmethod
    def search(
        self,
        collection: str,
        query: VectorQuery,
        top_k: int,
        *,
        where: Mapping[str, Any] | None = None,
        return_fields: Sequence[str] | None = None,
        include_distance: bool = True,
        include_metadata: bool = True,
    ) -> list[Mapping[str, Any]]:
        """Search the vector store and return results.

        When return_fields is provided, include_metadata is ignored.
        include_distance remains effective and adds `_distance` when enabled.
        """

create_collection(name, dimension) abstractmethod

Create a vector collection.

Source code in src/seekme/vector/core.py 
15
16
17
@abstractmethod
def create_collection(self, name: str, dimension: int) -> None:
    """Create a vector collection."""

delete_collection(name) abstractmethod

Delete a vector collection.

Source code in src/seekme/vector/core.py 
19
20
21
@abstractmethod
def delete_collection(self, name: str) -> None:
    """Delete a vector collection."""

search(collection, query, top_k, *, where=None, return_fields=None, include_distance=True, include_metadata=True) abstractmethod

Search the vector store and return results.

When return_fields is provided, include_metadata is ignored. include_distance remains effective and adds _distance when enabled.

Source code in src/seekme/vector/core.py 
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
@abstractmethod
def search(
    self,
    collection: str,
    query: VectorQuery,
    top_k: int,
    *,
    where: Mapping[str, Any] | None = None,
    return_fields: Sequence[str] | None = None,
    include_distance: bool = True,
    include_metadata: bool = True,
) -> list[Mapping[str, Any]]:
    """Search the vector store and return results.

    When return_fields is provided, include_metadata is ignored.
    include_distance remains effective and adds `_distance` when enabled.
    """

upsert(collection, ids, vectors, metadatas=None) abstractmethod

Insert or update vectors.

Source code in src/seekme/vector/core.py 
23
24
25
26
27
28
29
30
31
@abstractmethod
def upsert(
    self,
    collection: str,
    ids: Ids,
    vectors: Vectors,
    metadatas: Sequence[Mapping[str, Any]] | None = None,
) -> None:
    """Insert or update vectors."""

Embedding provider interfaces.

Embedder

Bases: Protocol

Protocol for embedding providers.

Source code in src/seekme/embeddings/base.py 
11
12
13
14
15
16
@runtime_checkable
class Embedder(Protocol):
    """Protocol for embedding providers."""

    def embed(self, texts: Sequence[Document]) -> list[Vector]:
        """Return embeddings for input texts."""

embed(texts)

Return embeddings for input texts.

Source code in src/seekme/embeddings/base.py 
15
16
def embed(self, texts: Sequence[Document]) -> list[Vector]:
    """Return embeddings for input texts."""

Remote embedding provider adapter.

RemoteEmbedder

Bases: Embedder

Embedding provider backed by a hosted embedding API.

Source code in src/seekme/embeddings/remote.py 
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
class RemoteEmbedder(Embedder):
    """Embedding provider backed by a hosted embedding API."""

    def __init__(
        self,
        *,
        model: str,
        provider: str | None = None,
        api_key: str | None = None,
        api_base: str | None = None,
        client_args: dict[str, Any] | None = None,
        **kwargs: Any,
    ) -> None:
        self._model = model
        self._provider = provider
        self._api_key = api_key
        self._api_base = api_base
        self._client_args = client_args
        self._kwargs = kwargs

    def embed(self, texts: Sequence[Document]) -> list[Vector]:
        if not texts:
            return []
        api = _load_remote_api()
        try:
            result = api.embedding(
                self._model,
                list(texts),
                provider=self._provider,
                api_key=self._api_key,
                api_base=self._api_base,
                client_args=self._client_args,
                **self._kwargs,
            )
        except Exception as exc:  # pragma: no cover - depends on provider runtime
            raise EmbeddingError.request_failed() from exc
        try:
            return _normalize_embeddings(result)
        except ValidationError:
            raise
        except Exception as exc:  # pragma: no cover - defensive parsing error
            raise EmbeddingError.response_failed() from exc

Local embedding provider adapter.

LocalEmbedder

Bases: Embedder

Embedding provider backed by sentence-transformers.

Source code in src/seekme/embeddings/local.py 
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
class LocalEmbedder(Embedder):
    """Embedding provider backed by sentence-transformers."""

    def __init__(
        self,
        *,
        model: str,
        device: str | None = None,
        normalize: bool = False,
        batch_size: int | None = None,
        encode_args: dict[str, Any] | None = None,
    ) -> None:
        if not model.strip():
            raise ValidationError.invalid_identifier("model")
        self._model_name = model
        self._device = device
        self._normalize = normalize
        self._batch_size = batch_size
        self._encode_args = encode_args or {}
        self._backend = None

    def embed(self, texts: Sequence[Document]) -> list[Vector]:
        if not texts:
            return []
        backend = self._load_backend()
        kwargs = dict(self._encode_args)
        kwargs["normalize_embeddings"] = self._normalize
        kwargs["show_progress_bar"] = False
        kwargs["convert_to_numpy"] = True
        if self._batch_size is not None:
            kwargs["batch_size"] = self._batch_size
        try:
            outputs = backend.encode(
                list(texts),
                **kwargs,
            )
        except Exception as exc:  # pragma: no cover - depends on runtime backend
            raise EmbeddingError.request_failed() from exc
        try:
            return outputs.tolist()
        except Exception as exc:
            raise EmbeddingError.response_failed() from exc

    def _load_backend(self):
        if self._backend is not None:
            return self._backend
        try:
            sentence_transformers = importlib.import_module("sentence_transformers")
        except ImportError as exc:  # pragma: no cover - optional dependency
            raise ConfigurationError.missing_optional_dependency("local-embeddings") from exc
        try:
            backend = sentence_transformers.SentenceTransformer(self._model_name, device=self._device)
        except Exception as exc:  # pragma: no cover - depends on runtime backend
            raise EmbeddingError.request_failed() from exc
        self._backend = backend
        return backend

Registry for SDK extension points.

ensure_defaults()

Load default implementations into the registry.

Source code in src/seekme/registry.py 
 92
 93
 94
 95
 96
 97
 98
 99
100
101
def ensure_defaults() -> None:
    """Load default implementations into the registry."""

    global _defaults_loaded
    if _defaults_loaded:
        return
    from ._defaults import register_defaults

    register_defaults()
    _defaults_loaded = True

get_db_driver(name)

Return the database driver factory for the given name.

Source code in src/seekme/registry.py 
44
45
46
47
48
49
50
51
def get_db_driver(name: str) -> DatabaseFactory:
    """Return the database driver factory for the given name."""

    key = _normalize_name(name)
    try:
        return _db_factories[key]
    except KeyError as exc:  # pragma: no cover - exercised via error path tests
        raise ConfigurationError.database_driver_not_found(name) from exc

get_embedder(name)

Return the embedder factory for the given name.

Source code in src/seekme/registry.py 
64
65
66
67
68
69
70
71
def get_embedder(name: str) -> EmbedderFactory:
    """Return the embedder factory for the given name."""

    key = _normalize_name(name)
    try:
        return _embedder_factories[key]
    except KeyError as exc:  # pragma: no cover - exercised via error path tests
        raise ConfigurationError.embedder_not_found(name) from exc

get_vector_store(name)

Return the vector store factory for the given name.

Source code in src/seekme/registry.py 
54
55
56
57
58
59
60
61
def get_vector_store(name: str) -> VectorStoreFactory:
    """Return the vector store factory for the given name."""

    key = _normalize_name(name)
    try:
        return _vector_factories[key]
    except KeyError as exc:  # pragma: no cover - exercised via error path tests
        raise ConfigurationError.vector_store_not_found(name) from exc

list_db_drivers()

List registered database driver names.

Source code in src/seekme/registry.py 
74
75
76
77
def list_db_drivers() -> Iterable[str]:
    """List registered database driver names."""

    return sorted(_db_factories)

list_embedders()

List registered embedder names.

Source code in src/seekme/registry.py 
86
87
88
89
def list_embedders() -> Iterable[str]:
    """List registered embedder names."""

    return sorted(_embedder_factories)

list_vector_stores()

List registered vector store names.

Source code in src/seekme/registry.py 
80
81
82
83
def list_vector_stores() -> Iterable[str]:
    """List registered vector store names."""

    return sorted(_vector_factories)

register_db_driver(name, factory)

Register a database driver factory.

Source code in src/seekme/registry.py 
26
27
28
29
def register_db_driver(name: str, factory: DatabaseFactory) -> None:
    """Register a database driver factory."""

    _db_factories[_normalize_name(name)] = factory

register_embedder(name, factory)

Register an embedder factory.

Source code in src/seekme/registry.py 
38
39
40
41
def register_embedder(name: str, factory: EmbedderFactory) -> None:
    """Register an embedder factory."""

    _embedder_factories[_normalize_name(name)] = factory

register_vector_store(name, factory)

Register a vector store factory.

Source code in src/seekme/registry.py 
32
33
34
35
def register_vector_store(name: str, factory: VectorStoreFactory) -> None:
    """Register a vector store factory."""

    _vector_factories[_normalize_name(name)] = factory