langchain-cyborgdb 0.1.0__tar.gz

langchain_cyborgdb-0.1.0/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025, Cyborg Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

langchain_cyborgdb-0.1.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: langchain-cyborgdb
+Version: 0.1.0
+Summary: LangChain integration for CyborgDB: The Confidential Vector Database
+Author: Cyborg Inc.
+License-Expression: MIT
+Project-URL: Homepage, https://www.cyborg.co
+Project-URL: Documentation, https://docs.cyborg.co/versions/latest/integrations/langchain/introduction
+Project-URL: Repository, https://github.com/cyborginc/langchain-cyborgdb
+Keywords: langchain,vectorstore,cyborgdb,encrypted,vector database
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cyborgdb-core[langchain]>=0.18.0
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# langchain-cyborgdb
+
+LangChain integration for [CyborgDB](https://www.cyborg.co), the Confidential Vector Database. Provides `CyborgVectorStore`, a [LangChain](https://www.langchain.com/) `VectorStore` backed by CyborgDB's encrypted vector indexes.
+
+This package is a thin wrapper around the integration that ships in [`cyborgdb-core`](https://pypi.org/project/cyborgdb-core/) — it re-exports `CyborgVectorStore`, `CyborgEmbeddings`, and `StorageConfig` under the standalone package name that LangChain's integration directory expects.
+
+## Installation
+
+```bash
+pip install langchain-cyborgdb
+```
+
+## Quick Start
+
+The example below uses OpenAI embeddings (`pip install langchain-openai`), but any LangChain `Embeddings` implementation works. You'll need a CyborgDB API key from [cyborg.co](https://www.cyborg.co).
+
+```python
+from langchain_cyborgdb import CyborgVectorStore, StorageConfig
+from langchain_openai import OpenAIEmbeddings
+
+store = CyborgVectorStore.from_texts(
+    texts=["hello world", "goodbye world"],
+    embedding=OpenAIEmbeddings(),
+    index_key=CyborgVectorStore.generate_key(),
+    api_key="your-api-key",
+    storage_config=StorageConfig.disk("/tmp/cyborgdb-langchain"),
+    metric="cosine"
+)
+
+docs = store.similarity_search("hello")
+```
+
+## Key Features
+
+- Full VectorStore API compatibility (`add_texts`, `similarity_search`, etc.)
+- Async operations support
+- Configurable distance metrics (`cosine`, `euclidean`, `squared_euclidean`)
+- Document ID tracking and management
+- Max marginal relevance search
+- Factory methods (`from_texts`, `from_documents`) for quick setup
+
+## Key Classes
+
+### `CyborgVectorStore`
+
+Implements the LangChain-compatible vector store interface. Supports:
+
+- `.add_texts()` / `.add_documents()`
+- `.similarity_search()` / `.similarity_search_with_score()`
+- `.max_marginal_relevance_search()`
+- `.get()` / `.list_ids()` / `.delete()`
+- `.as_retriever()` for use in LangChain chains
+- Async variants (`.aadd_texts()`, `.asimilarity_search()`, etc.)
+
+### `StorageConfig`
+
+Configuration object for defining where index data is stored, built with `StorageConfig.disk(path)` or `StorageConfig.s3(bucket, ...)`.
+
+## Documentation
+
+Full documentation, including metadata filtering and hybrid (BM25) search, lives at [docs.cyborg.co](https://docs.cyborg.co/versions/latest/integrations/langchain/introduction).
+
+Using the CyborgDB client/server deployment instead of the embedded engine? The same integration is available via `pip install cyborgdb[langchain]` — see the [Deployment Models Guide](https://docs.cyborg.co/versions/latest/intro/deployment-models).
+
+## License
+
+This wrapper is MIT licensed. It depends on `cyborgdb-core`, which is distributed under its own [proprietary license](https://www.cyborg.co).

langchain_cyborgdb-0.1.0/README.md

@@ -0,0 +1,67 @@
+# langchain-cyborgdb
+
+LangChain integration for [CyborgDB](https://www.cyborg.co), the Confidential Vector Database. Provides `CyborgVectorStore`, a [LangChain](https://www.langchain.com/) `VectorStore` backed by CyborgDB's encrypted vector indexes.
+
+This package is a thin wrapper around the integration that ships in [`cyborgdb-core`](https://pypi.org/project/cyborgdb-core/) — it re-exports `CyborgVectorStore`, `CyborgEmbeddings`, and `StorageConfig` under the standalone package name that LangChain's integration directory expects.
+
+## Installation
+
+```bash
+pip install langchain-cyborgdb
+```
+
+## Quick Start
+
+The example below uses OpenAI embeddings (`pip install langchain-openai`), but any LangChain `Embeddings` implementation works. You'll need a CyborgDB API key from [cyborg.co](https://www.cyborg.co).
+
+```python
+from langchain_cyborgdb import CyborgVectorStore, StorageConfig
+from langchain_openai import OpenAIEmbeddings
+
+store = CyborgVectorStore.from_texts(
+    texts=["hello world", "goodbye world"],
+    embedding=OpenAIEmbeddings(),
+    index_key=CyborgVectorStore.generate_key(),
+    api_key="your-api-key",
+    storage_config=StorageConfig.disk("/tmp/cyborgdb-langchain"),
+    metric="cosine"
+)
+
+docs = store.similarity_search("hello")
+```
+
+## Key Features
+
+- Full VectorStore API compatibility (`add_texts`, `similarity_search`, etc.)
+- Async operations support
+- Configurable distance metrics (`cosine`, `euclidean`, `squared_euclidean`)
+- Document ID tracking and management
+- Max marginal relevance search
+- Factory methods (`from_texts`, `from_documents`) for quick setup
+
+## Key Classes
+
+### `CyborgVectorStore`
+
+Implements the LangChain-compatible vector store interface. Supports:
+
+- `.add_texts()` / `.add_documents()`
+- `.similarity_search()` / `.similarity_search_with_score()`
+- `.max_marginal_relevance_search()`
+- `.get()` / `.list_ids()` / `.delete()`
+- `.as_retriever()` for use in LangChain chains
+- Async variants (`.aadd_texts()`, `.asimilarity_search()`, etc.)
+
+### `StorageConfig`
+
+Configuration object for defining where index data is stored, built with `StorageConfig.disk(path)` or `StorageConfig.s3(bucket, ...)`.
+
+## Documentation
+
+Full documentation, including metadata filtering and hybrid (BM25) search, lives at [docs.cyborg.co](https://docs.cyborg.co/versions/latest/integrations/langchain/introduction).
+
+Using the CyborgDB client/server deployment instead of the embedded engine? The same integration is available via `pip install cyborgdb[langchain]` — see the [Deployment Models Guide](https://docs.cyborg.co/versions/latest/intro/deployment-models).
+
+## License
+
+This wrapper is MIT licensed. It depends on `cyborgdb-core`, which is distributed under its own [proprietary license](https://www.cyborg.co).

langchain_cyborgdb-0.1.0/langchain_cyborgdb/__init__.py

@@ -0,0 +1,16 @@
+"""LangChain integration for CyborgDB.
+
+This package is a thin wrapper around ``cyborgdb_core.integrations.langchain``,
+published under the standalone name LangChain's integration directory expects.
+All functionality lives in ``cyborgdb-core[langchain]``.
+"""
+
+from cyborgdb_core.integrations.langchain import (
+    CyborgEmbeddings,
+    CyborgVectorStore,
+    StorageConfig,
+)
+
+__version__ = "0.1.0"
+
+__all__ = ["CyborgVectorStore", "CyborgEmbeddings", "StorageConfig"]

langchain_cyborgdb-0.1.0/langchain_cyborgdb.egg-info/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: langchain-cyborgdb
+Version: 0.1.0
+Summary: LangChain integration for CyborgDB: The Confidential Vector Database
+Author: Cyborg Inc.
+License-Expression: MIT
+Project-URL: Homepage, https://www.cyborg.co
+Project-URL: Documentation, https://docs.cyborg.co/versions/latest/integrations/langchain/introduction
+Project-URL: Repository, https://github.com/cyborginc/langchain-cyborgdb
+Keywords: langchain,vectorstore,cyborgdb,encrypted,vector database
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cyborgdb-core[langchain]>=0.18.0
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# langchain-cyborgdb
+
+LangChain integration for [CyborgDB](https://www.cyborg.co), the Confidential Vector Database. Provides `CyborgVectorStore`, a [LangChain](https://www.langchain.com/) `VectorStore` backed by CyborgDB's encrypted vector indexes.
+
+This package is a thin wrapper around the integration that ships in [`cyborgdb-core`](https://pypi.org/project/cyborgdb-core/) — it re-exports `CyborgVectorStore`, `CyborgEmbeddings`, and `StorageConfig` under the standalone package name that LangChain's integration directory expects.
+
+## Installation
+
+```bash
+pip install langchain-cyborgdb
+```
+
+## Quick Start
+
+The example below uses OpenAI embeddings (`pip install langchain-openai`), but any LangChain `Embeddings` implementation works. You'll need a CyborgDB API key from [cyborg.co](https://www.cyborg.co).
+
+```python
+from langchain_cyborgdb import CyborgVectorStore, StorageConfig
+from langchain_openai import OpenAIEmbeddings
+
+store = CyborgVectorStore.from_texts(
+    texts=["hello world", "goodbye world"],
+    embedding=OpenAIEmbeddings(),
+    index_key=CyborgVectorStore.generate_key(),
+    api_key="your-api-key",
+    storage_config=StorageConfig.disk("/tmp/cyborgdb-langchain"),
+    metric="cosine"
+)
+
+docs = store.similarity_search("hello")
+```
+
+## Key Features
+
+- Full VectorStore API compatibility (`add_texts`, `similarity_search`, etc.)
+- Async operations support
+- Configurable distance metrics (`cosine`, `euclidean`, `squared_euclidean`)
+- Document ID tracking and management
+- Max marginal relevance search
+- Factory methods (`from_texts`, `from_documents`) for quick setup
+
+## Key Classes
+
+### `CyborgVectorStore`
+
+Implements the LangChain-compatible vector store interface. Supports:
+
+- `.add_texts()` / `.add_documents()`
+- `.similarity_search()` / `.similarity_search_with_score()`
+- `.max_marginal_relevance_search()`
+- `.get()` / `.list_ids()` / `.delete()`
+- `.as_retriever()` for use in LangChain chains
+- Async variants (`.aadd_texts()`, `.asimilarity_search()`, etc.)
+
+### `StorageConfig`
+
+Configuration object for defining where index data is stored, built with `StorageConfig.disk(path)` or `StorageConfig.s3(bucket, ...)`.
+
+## Documentation
+
+Full documentation, including metadata filtering and hybrid (BM25) search, lives at [docs.cyborg.co](https://docs.cyborg.co/versions/latest/integrations/langchain/introduction).
+
+Using the CyborgDB client/server deployment instead of the embedded engine? The same integration is available via `pip install cyborgdb[langchain]` — see the [Deployment Models Guide](https://docs.cyborg.co/versions/latest/intro/deployment-models).
+
+## License
+
+This wrapper is MIT licensed. It depends on `cyborgdb-core`, which is distributed under its own [proprietary license](https://www.cyborg.co).

langchain_cyborgdb-0.1.0/langchain_cyborgdb.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+langchain_cyborgdb/__init__.py
+langchain_cyborgdb.egg-info/PKG-INFO
+langchain_cyborgdb.egg-info/SOURCES.txt
+langchain_cyborgdb.egg-info/dependency_links.txt
+langchain_cyborgdb.egg-info/requires.txt
+langchain_cyborgdb.egg-info/top_level.txt
+tests/test_functional.py
+tests/test_imports.py

langchain_cyborgdb-0.1.0/langchain_cyborgdb.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

langchain_cyborgdb-0.1.0/langchain_cyborgdb.egg-info/requires.txt

@@ -0,0 +1,4 @@
+cyborgdb-core[langchain]>=0.18.0
+
+[test]
+pytest

langchain_cyborgdb-0.1.0/langchain_cyborgdb.egg-info/top_level.txt

@@ -0,0 +1 @@
+langchain_cyborgdb

langchain_cyborgdb-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "langchain-cyborgdb"
+version = "0.1.0"
+description = "LangChain integration for CyborgDB: The Confidential Vector Database"
+readme = "README.md"
+requires-python = ">= 3.10"
+license = "MIT"
+authors = [{ name = "Cyborg Inc." }]
+keywords = ["langchain", "vectorstore", "cyborgdb", "encrypted", "vector database"]
+dependencies = ["cyborgdb-core[langchain] >= 0.18.0"]
+classifiers = [
+    "Intended Audience :: Developers",
+    "Intended Audience :: Information Technology",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Database",
+    "Topic :: Security :: Cryptography",
+    "Topic :: Software Development :: Libraries",
+]
+
+[project.urls]
+"Homepage" = "https://www.cyborg.co"
+"Documentation" = "https://docs.cyborg.co/versions/latest/integrations/langchain/introduction"
+"Repository" = "https://github.com/cyborginc/langchain-cyborgdb"
+
+[project.optional-dependencies]
+test = ["pytest"]
+
+[tool.setuptools.packages.find]
+include = ["langchain_cyborgdb*"]

langchain_cyborgdb-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

langchain_cyborgdb-0.1.0/tests/test_functional.py

@@ -0,0 +1,189 @@
+"""Functional tests: the re-exported integration works end-to-end.
+
+Adapted from cyborgdb-core's py_langchain_test.py, but importing everything
+through ``langchain_cyborgdb`` — proving the wrapper exposes a working
+integration, not just importable names.
+
+Uses DeterministicFakeEmbedding (identical text -> identical vector), so
+exact-text queries must return that text as the top hit and no embedding
+model download or OpenAI key is needed. Semantic-quality tests (synonym /
+paraphrase search) stay in cyborgdb-core where the real models live.
+
+cyborgdb-core validates the CyborgDB API key against Cyborg's backend, so
+the whole module is skipped unless CYBORGDB_API_KEY is set.
+"""
+
+import os
+import uuid
+
+import pytest
+from langchain_core.documents import Document
+from langchain_core.embeddings import DeterministicFakeEmbedding
+
+from langchain_cyborgdb import CyborgVectorStore, StorageConfig
+
+pytestmark = pytest.mark.skipif(
+    not os.environ.get("CYBORGDB_API_KEY"),
+    reason="CYBORGDB_API_KEY not set; functional tests need a real key",
+)
+
+EMBEDDING = DeterministicFakeEmbedding(size=128)
+
+
+@pytest.fixture
+def make_store(tmp_path):
+    """Build stores with unique index names; delete their indexes afterward."""
+    stores = []
+
+    def _make(texts=None, metadatas=None, ids=None, documents=None, **overrides):
+        kwargs = dict(
+            embedding=EMBEDDING,
+            index_name=f"lc_wrapper_{uuid.uuid4().hex[:12]}",
+            index_key=CyborgVectorStore.generate_key(),
+            api_key=os.environ["CYBORGDB_API_KEY"],
+            storage_config=StorageConfig.disk(str(tmp_path)),
+            metric="cosine",
+        )
+        kwargs.update(overrides)
+        if documents is not None:
+            store = CyborgVectorStore.from_documents(documents=documents, **kwargs)
+        elif texts is not None:
+            store = CyborgVectorStore.from_texts(
+                texts=texts, metadatas=metadatas, ids=ids, **kwargs
+            )
+        else:
+            store = CyborgVectorStore(**kwargs)
+        stores.append(store)
+        return store
+
+    yield _make
+
+    for store in stores:
+        try:
+            store.delete(delete_index=True)
+        except Exception:
+            pass
+
+
+def test_quickstart_flow(make_store):
+    """The docs quickstart shape: from_texts -> similarity_search."""
+    store = make_store(texts=["hello world", "goodbye world"])
+
+    docs = store.similarity_search("hello world", k=2)
+
+    assert len(docs) == 2
+    assert docs[0].page_content == "hello world"
+    assert {doc.page_content for doc in docs} == {"hello world", "goodbye world"}
+
+
+def test_search_methods_return_contents_and_metadata(make_store):
+    texts = ["cat on a mat", "dog in a fog", "bird on a wire", "fish in a dish"]
+    metadatas = [{"animal": text.split()[0], "idx": i} for i, text in enumerate(texts)]
+    expected = dict(zip(texts, metadatas))
+    store = make_store(texts=texts, metadatas=metadatas)
+
+    query = "cat on a mat"
+    searches = {
+        "similarity_search": store.similarity_search(query, k=4),
+        "similarity_search_with_score": [
+            doc for doc, _ in store.similarity_search_with_score(query, k=4)
+        ],
+        "similarity_search_by_vector": store.similarity_search_by_vector(
+            EMBEDDING.embed_query(query), k=4
+        ),
+    }
+    for name, docs in searches.items():
+        assert len(docs) == len(texts), name
+        for doc in docs:
+            assert doc.page_content in expected, name
+            assert doc.metadata == expected[doc.page_content], name
+
+
+def test_metadata_filtering(make_store):
+    texts = [f"Doc {i}" for i in range(10)]
+    metadatas = [
+        {"owner": {"name": "Jane" if i % 2 == 0 else "John"}} for i in range(10)
+    ]
+    store = make_store(texts=texts, metadatas=metadatas)
+
+    results = store.similarity_search(
+        "Doc 0", k=10, filter={"owner.name": {"$eq": "Jane"}}
+    )
+
+    assert results
+    assert all(doc.metadata["owner"]["name"] == "Jane" for doc in results)
+
+
+def test_delete_documents(make_store):
+    texts = [f"Delete Me {i}" for i in range(5)]
+    store = make_store()
+    ids = store.add_texts(texts, metadatas=[{"n": i} for i in range(5)])
+    assert len(ids) == 5
+
+    store.delete(ids=[ids[1], ids[3]])
+
+    remaining = store.similarity_search("Delete Me 0", k=5)
+    remaining_ns = {doc.metadata["n"] for doc in remaining}
+    assert remaining_ns == {0, 2, 4}
+
+
+def test_mmr_search(make_store):
+    texts = [f"topic {i} foxes and dogs" for i in range(10)]
+    store = make_store(
+        texts=texts, metadatas=[{"category": f"group_{i % 3}"} for i in range(10)]
+    )
+
+    results = store.max_marginal_relevance_search(
+        "topic 1 foxes and dogs", k=3, fetch_k=6, lambda_mult=0.5
+    )
+
+    assert len(results) == 3
+
+
+def test_from_documents(make_store):
+    documents = [
+        Document(page_content=f"LangChain doc {i}", metadata={"category": "test"})
+        for i in range(10)
+    ]
+    store = make_store(documents=documents)
+
+    results = store.similarity_search("LangChain doc 5", k=2)
+
+    assert results
+    assert results[0].page_content == "LangChain doc 5"
+    assert results[0].metadata == {"category": "test"}
+
+
+def test_list_ids_get_and_upsert(make_store):
+    texts = ["alpha text", "beta text", "gamma text"]
+    ids = ["doc_001", "doc_002", "doc_003"]
+    store = make_store()
+    store.add_texts(texts, [{"pos": i} for i in range(3)], ids=ids)
+
+    assert sorted(store.list_ids()) == ids
+
+    doc = store.get_document("doc_002")
+    assert doc is not None
+    assert doc.page_content == "beta text"
+    assert doc.metadata == {"pos": 1}
+
+    docs = store.get_documents(["doc_001", "doc_003", "doc_999"])
+    assert len(docs) == 3
+    assert docs[0] is not None and docs[1] is not None
+    assert docs[2] is None
+
+    # Re-adding an existing ID upserts rather than duplicating.
+    store.add_texts(["alpha text updated"], ids=["doc_001"])
+    assert len(store.list_ids()) == 3
+    assert store.get_document("doc_001").page_content == "alpha text updated"
+
+
+def test_as_retriever(make_store):
+    texts = ["red apple", "green pear", "blue sky"]
+    store = make_store(texts=texts)
+
+    retriever = store.as_retriever(search_kwargs={"k": 2})
+    docs = retriever.invoke("red apple")
+
+    assert len(docs) == 2
+    assert docs[0].page_content == "red apple"

langchain_cyborgdb-0.1.0/tests/test_imports.py

@@ -0,0 +1,26 @@
+"""Smoke tests: the package installs and the public API is importable.
+
+These mirror the acceptance criteria on cyborginc/cyborgdb-core#2719 —
+`from langchain_cyborgdb import CyborgVectorStore, StorageConfig` must work
+in a clean environment against cyborgdb-core 0.18.x.
+"""
+
+from langchain_core.vectorstores import VectorStore
+
+import langchain_cyborgdb
+from langchain_cyborgdb import CyborgEmbeddings, CyborgVectorStore, StorageConfig
+
+
+def test_cyborg_vector_store_is_a_langchain_vectorstore():
+    assert issubclass(CyborgVectorStore, VectorStore)
+
+
+def test_storage_config_factories_exist():
+    assert callable(StorageConfig.disk)
+    assert callable(StorageConfig.s3)
+
+
+def test_public_api_matches_all():
+    for name in langchain_cyborgdb.__all__:
+        assert getattr(langchain_cyborgdb, name) is not None
+    assert CyborgEmbeddings is not None