from vecta import VectaAPIClient

client = VectaAPIClient(api_key="your-key")

db = client.connect_chroma_cloud(
    tenant="your-tenant",
    database="your-db",
    api_key="your-chroma-key",
    collection_name="documents"
)

db = client.connect_pinecone(
    api_key="your-pinecone-key",
    index_name="your-index",
    namespace=""  # optional
)

from vecta.connectors.pgvector_connector import PgVectorConnector
from vecta.core.schema_helpers import SchemaTemplates

connector = PgVectorConnector(
    dsn="postgresql://user:pass@host:5432/db",
    table="chunks",
    schema=SchemaTemplates.pgvector_standard()
)

from vecta import VectaClient
from vecta.connectors.chroma_local_connector import ChromaLocalConnector
from vecta.core.schema_helpers import SchemaTemplates
from chromadb import Client

chroma = Client()
connector = ChromaLocalConnector(
    client=chroma,
    collection_name="documents",
    schema=SchemaTemplates.chroma_default()
)

vecta = VectaClient(vector_db_connector=connector)

from vecta.connectors.weaviate_connector import WeaviateConnector
from vecta.core.schema_helpers import SchemaTemplates

connector = WeaviateConnector(
    cluster_url="https://your-cluster.weaviate.cloud",
    api_key="your-key",
    collection_name="Documents",
    schema=SchemaTemplates.weaviate_default()
)

from vecta.connectors.azure_cosmos_connector import AzureCosmosConnector
from vecta.core.schemas import VectorDBSchema

connector = AzureCosmosConnector(
    endpoint="https://your-account.documents.azure.com:443/",
    key="your-key",
    database_name="your-db",
    container_name="chunks",
    schema=VectorDBSchema(
        id_accessor="id",
        content_accessor="content",
        source_path_accessor="metadata.source",
        page_nums_accessor="metadata.pages"
    )
)

from vecta.connectors.databricks_connector import DatabricksConnector

connector = DatabricksConnector(
    workspace_url="https://your-workspace.cloud.databricks.com",
    index_name="your_index",
    personal_access_token="your-token",
    schema=SchemaTemplates.databricks_indexed()
)

from vecta.connectors.langchain_connector import LangChainVectorStoreConnector
from vecta.core.schema_helpers import SchemaTemplates

# Works with any LangChain VectorStore
connector = LangChainVectorStoreConnector(
    vectorstore=your_langchain_store,
    schema=SchemaTemplates.chroma_default()  # Adjust for your store
)

from vecta.connectors.llama_index_connector import LlamaIndexConnector
from vecta.core.schemas import VectorDBSchema

connector = LlamaIndexConnector(
    index=your_llama_index,
    schema=VectorDBSchema(
        id_accessor="node_id",
        content_accessor="content",
        source_path_accessor="metadata.file_name",
        page_nums_accessor="metadata.pages"
    )
)

from vecta.connectors.base import BaseVectorDBConnector
from vecta.core.schemas import ChunkData, VectorDBSchema

class MyConnector(BaseVectorDBConnector):
    def __init__(self, client, schema: VectorDBSchema):
        super().__init__(schema)
        self.client = client

    def get_all_chunks(self) -> list[ChunkData]:
        results = self.client.fetch_all()
        return [self._create_chunk_data_from_raw(r) for r in results]

    def semantic_search(self, query: str, k: int) -> list[ChunkData]:
        results = self.client.search(query, limit=k)
        return [self._create_chunk_data_from_raw(r) for r in results]

    def get_chunk_by_id(self, chunk_id: str) -> ChunkData:
        result = self.client.get(chunk_id)
        return self._create_chunk_data_from_raw(result)

from vecta.core.schema_helpers import SchemaTemplates

# ChromaDB
schema = SchemaTemplates.chroma_default()

# Pinecone
schema = SchemaTemplates.pinecone_default()

# PostgreSQL (standard - metadata as JSON column)
schema = SchemaTemplates.pgvector_standard()

# PostgreSQL (flat - separate columns)
schema = SchemaTemplates.pgvector_flat(
    id_col="id",
    content_col="content",
    source_path_col="file_name",
    page_nums_col="pages"
)

# Weaviate
schema = SchemaTemplates.weaviate_default()

# Databricks
schema = SchemaTemplates.databricks_indexed()