wavemind 2.0.0__tar.gz → 2.0.1__tar.gz

{wavemind-2.0.0 → wavemind-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavemind
-Version: 2.0.0
+Version: 2.0.1
 Summary: Persistent dynamic memory engine with vector search and wave-field re-ranking
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/CaspianG/wavemind
@@ -20,6 +20,10 @@ Requires-Dist: sentence-transformers>=3; extra == "ml"
 Provides-Extra: indexes
 Requires-Dist: annoy>=1.17; extra == "indexes"
 Requires-Dist: faiss-cpu>=1.8; platform_system != "Windows" and extra == "indexes"
+Provides-Extra: bench
+Requires-Dist: chromadb>=1.0; extra == "bench"
+Provides-Extra: langchain
+Requires-Dist: langchain-classic>=1.0; extra == "langchain"
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
 Requires-Dist: httpx>=0.27; extra == "dev"
@@ -73,6 +77,29 @@ sh install.sh
 install.bat
 ```
 
+## LangChain Memory
+
+Install the optional integration:
+
+```sh
+pip install "wavemind[langchain]"
+```
+
+Use WaveMind as a drop-in LangChain memory object:
+
+```python
+from wavemind.integrations.langchain import WaveMindMemory
+
+memory = WaveMindMemory(db_path="agent_memory.sqlite3")
+# Replace: memory = ConversationBufferMemory()
+```
+
+Offline runnable example:
+
+```sh
+python examples/langchain_memory.py
+```
+
 ## Benchmark
 
 Real Russian sentences from Tatoeba, 50 one-word queries, NumPy exact index.
@@ -98,6 +125,23 @@ python benchmarks/ru_sentences_benchmark.py --sentences 200 --queries 50 --encod
 python benchmarks/ru_sentences_benchmark.py --sentences 200 --queries 50 --encoder sentence --index numpy
 ```
 
+Agent-memory benchmark against Chroma:
+
+200 Russian user facts, 50 natural-language questions, same precomputed `HashingTextEncoder` embeddings for WaveMind and Chroma.
+Full machine-readable result: `benchmarks/agent_memory_results.json`.
+
+| engine | precision@1 | precision@3 | avg latency |
+|---|---:|---:|---:|
+| WaveMind | 0.82 | 0.90 | 2.25 ms |
+| Chroma | 0.82 | 0.88 | 0.93 ms |
+
+Run locally:
+
+```sh
+pip install -e ".[bench]"
+python benchmarks/agent_memory_benchmark.py --engines wavemind chroma --facts 200 --queries 50
+```
+
 ## Comparison
 
 | feature | WaveMind | Chroma | Qdrant |
@@ -118,12 +162,13 @@ WaveMind is not trying to replace dedicated vector databases at scale. Its diffe
 - At 5000 records, one-word `precision@1` is currently 0.72 with the hash encoder; many misses are ambiguous queries where another sentence containing the same word ranks first.
 - For `N > 5000`, use the FAISS backend with `--index faiss` or another production vector index.
 - `sentence-transformers/paraphrase-multilingual-mpnet-base-v2` requires about 420 MB of model files and measured about 53 ms per query on the benchmark machine.
-- The bundled benchmark is a retrieval sanity check, not a full agent-memory benchmark against Chroma or Qdrant yet.
+- The Chroma comparison currently uses shared precomputed hash embeddings to isolate retrieval/ranking behavior; semantic model comparisons should be run separately.
+- In the 200-fact agent benchmark, Chroma is faster on average while WaveMind is slightly higher at `precision@3`.
 
 ## Roadmap
 
 - FAISS-first production index path with persisted index rebuilds.
-- Larger public benchmark against Chroma and Qdrant on agent-memory tasks.
+- Expand the agent-memory benchmark to sentence-transformers, FAISS, Chroma default embeddings, and Qdrant.
 - Better semantic query expansion for short and ambiguous queries.
 - Namespace quotas, backups, and daemon hardening for SaaS use.
 - Webhook on recall for agent runtimes.

{wavemind-2.0.0 → wavemind-2.0.1}/README.md

@@ -46,6 +46,29 @@ sh install.sh
 install.bat
 ```
 
+## LangChain Memory
+
+Install the optional integration:
+
+```sh
+pip install "wavemind[langchain]"
+```
+
+Use WaveMind as a drop-in LangChain memory object:
+
+```python
+from wavemind.integrations.langchain import WaveMindMemory
+
+memory = WaveMindMemory(db_path="agent_memory.sqlite3")
+# Replace: memory = ConversationBufferMemory()
+```
+
+Offline runnable example:
+
+```sh
+python examples/langchain_memory.py
+```
+
 ## Benchmark
 
 Real Russian sentences from Tatoeba, 50 one-word queries, NumPy exact index.
@@ -71,6 +94,23 @@ python benchmarks/ru_sentences_benchmark.py --sentences 200 --queries 50 --encod
 python benchmarks/ru_sentences_benchmark.py --sentences 200 --queries 50 --encoder sentence --index numpy
 ```
 
+Agent-memory benchmark against Chroma:
+
+200 Russian user facts, 50 natural-language questions, same precomputed `HashingTextEncoder` embeddings for WaveMind and Chroma.
+Full machine-readable result: `benchmarks/agent_memory_results.json`.
+
+| engine | precision@1 | precision@3 | avg latency |
+|---|---:|---:|---:|
+| WaveMind | 0.82 | 0.90 | 2.25 ms |
+| Chroma | 0.82 | 0.88 | 0.93 ms |
+
+Run locally:
+
+```sh
+pip install -e ".[bench]"
+python benchmarks/agent_memory_benchmark.py --engines wavemind chroma --facts 200 --queries 50
+```
+
 ## Comparison
 
 | feature | WaveMind | Chroma | Qdrant |
@@ -91,12 +131,13 @@ WaveMind is not trying to replace dedicated vector databases at scale. Its diffe
 - At 5000 records, one-word `precision@1` is currently 0.72 with the hash encoder; many misses are ambiguous queries where another sentence containing the same word ranks first.
 - For `N > 5000`, use the FAISS backend with `--index faiss` or another production vector index.
 - `sentence-transformers/paraphrase-multilingual-mpnet-base-v2` requires about 420 MB of model files and measured about 53 ms per query on the benchmark machine.
-- The bundled benchmark is a retrieval sanity check, not a full agent-memory benchmark against Chroma or Qdrant yet.
+- The Chroma comparison currently uses shared precomputed hash embeddings to isolate retrieval/ranking behavior; semantic model comparisons should be run separately.
+- In the 200-fact agent benchmark, Chroma is faster on average while WaveMind is slightly higher at `precision@3`.
 
 ## Roadmap
 
 - FAISS-first production index path with persisted index rebuilds.
-- Larger public benchmark against Chroma and Qdrant on agent-memory tasks.
+- Expand the agent-memory benchmark to sentence-transformers, FAISS, Chroma default embeddings, and Qdrant.
 - Better semantic query expansion for short and ambiguous queries.
 - Namespace quotas, backups, and daemon hardening for SaaS use.
 - Webhook on recall for agent runtimes.

{wavemind-2.0.0 → wavemind-2.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wavemind"
-version = "2.0.0"
+version = "2.0.1"
 description = "Persistent dynamic memory engine with vector search and wave-field re-ranking"
 readme = "README.md"
 license = "MIT"
@@ -28,6 +28,12 @@ indexes = [
   "annoy>=1.17",
   "faiss-cpu>=1.8; platform_system != 'Windows'",
 ]
+bench = [
+  "chromadb>=1.0",
+]
+langchain = [
+  "langchain-classic>=1.0",
+]
 dev = [
   "pytest>=8",
   "httpx>=0.27",

wavemind-2.0.1/tests/test_agent_memory_benchmark.py

@@ -0,0 +1,74 @@
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def test_agent_memory_scenario_has_requested_shape():
+    from benchmarks.agent_memory_benchmark import build_agent_memory_scenario
+
+    scenario = build_agent_memory_scenario()
+    fact_ids = {fact.id for fact in scenario.facts}
+
+    assert len(scenario.facts) == 200
+    assert len(scenario.queries) == 50
+    assert len(fact_ids) == 200
+    assert all(query.expected_id in fact_ids for query in scenario.queries)
+    assert any("бюджет" in query.text.lower() for query in scenario.queries)
+    assert any("зовут" in query.text.lower() for query in scenario.queries)
+
+
+def test_agent_memory_metrics_use_expected_fact_in_top_k():
+    from benchmarks.agent_memory_benchmark import AgentQuery, compute_metrics
+
+    queries = [
+        AgentQuery(id="q1", text="как зовут пользователя?", expected_id="fact_name"),
+        AgentQuery(id="q2", text="что знаем про бюджет?", expected_id="fact_budget"),
+    ]
+    rankings = {
+        "q1": ["fact_name", "fact_role", "fact_budget"],
+        "q2": ["fact_role", "fact_budget", "fact_name"],
+    }
+
+    metrics = compute_metrics(queries, rankings, [1.0, 3.0])
+
+    assert metrics.precision_at_1 == 0.5
+    assert metrics.precision_at_3 == 1.0
+    assert metrics.avg_latency_ms == 2.0
+
+
+def test_agent_memory_benchmark_cli_writes_json_for_wavemind(tmp_path):
+    output = tmp_path / "agent-memory-result.json"
+    project_root = Path(__file__).resolve().parents[1]
+    env = os.environ.copy()
+    env["PYTHONPATH"] = str(project_root) + os.pathsep + env.get("PYTHONPATH", "")
+
+    subprocess.run(
+        [
+            sys.executable,
+            "benchmarks/agent_memory_benchmark.py",
+            "--engines",
+            "wavemind",
+            "--facts",
+            "20",
+            "--queries",
+            "5",
+            "--output",
+            str(output),
+        ],
+        cwd=project_root,
+        env=env,
+        text=True,
+        encoding="utf-8",
+        capture_output=True,
+        check=True,
+    )
+
+    payload = json.loads(output.read_text(encoding="utf-8"))
+
+    assert payload["scenario"]["facts"] == 20
+    assert payload["scenario"]["queries"] == 5
+    assert payload["results"][0]["engine"] == "WaveMind"
+    assert "precision_at_1" in payload["results"][0]
+    assert "avg_latency_ms" in payload["results"][0]

wavemind-2.0.1/tests/test_langchain_integration.py

@@ -0,0 +1,86 @@
+import subprocess
+import sys
+from pathlib import Path
+
+from wavemind import HashingTextEncoder, WaveMind
+
+
+def make_memory(tmp_path):
+    from wavemind.integrations.langchain import WaveMindMemory
+
+    mind = WaveMind(
+        db_path=tmp_path / "langchain.sqlite3",
+        encoder=HashingTextEncoder(vector_dim=128),
+        width=32,
+        height=32,
+        layers=2,
+        evolve_on_feed=1,
+        score_threshold=0.0,
+    )
+    return WaveMindMemory(memory=mind, top_k=3)
+
+
+def test_wavemind_memory_exposes_langchain_base_memory_methods(tmp_path):
+    memory = make_memory(tmp_path)
+
+    assert memory.memory_variables == ["history"]
+    assert hasattr(memory, "load_memory_variables")
+    assert hasattr(memory, "save_context")
+    assert hasattr(memory, "clear")
+
+
+def test_wavemind_memory_saves_context_and_recalls_relevant_history(tmp_path):
+    memory = make_memory(tmp_path)
+
+    memory.save_context(
+        {"input": "my name is Andrey and I am a trader"},
+        {"output": "remembered"},
+    )
+    loaded = memory.load_memory_variables({"input": "what is my name?"})
+
+    assert set(loaded) == {"history"}
+    assert "Andrey" in loaded["history"]
+    assert "trader" in loaded["history"]
+
+
+def test_wavemind_memory_supports_custom_input_output_keys(tmp_path):
+    memory = make_memory(tmp_path)
+    memory.input_key = "question"
+    memory.output_key = "answer"
+
+    memory.save_context(
+        {"question": "the user budget is 2000 dollars", "irrelevant": "skip me"},
+        {"answer": "saved", "other": "ignore me"},
+    )
+    loaded = memory.load_memory_variables({"question": "what is the budget?"})
+
+    assert "2000 dollars" in loaded["history"]
+    assert "skip me" not in loaded["history"]
+    assert "ignore me" not in loaded["history"]
+
+
+def test_wavemind_memory_clear_forgets_namespace(tmp_path):
+    memory = make_memory(tmp_path)
+
+    memory.save_context({"input": "Andrey likes short answers"}, {"output": "ok"})
+    assert "Andrey" in memory.load_memory_variables({"input": "short answers"})["history"]
+
+    memory.clear()
+
+    assert memory.load_memory_variables({"input": "short answers"})["history"] == ""
+
+
+def test_langchain_example_runs_without_external_keys():
+    project_root = Path(__file__).resolve().parents[1]
+
+    result = subprocess.run(
+        [sys.executable, "examples/langchain_memory.py"],
+        cwd=project_root,
+        text=True,
+        encoding="utf-8",
+        capture_output=True,
+        check=True,
+    )
+
+    assert "WaveMindMemory history:" in result.stdout
+    assert "Andrey" in result.stdout

{wavemind-2.0.0 → wavemind-2.0.1}/tests/test_packaging_files.py

@@ -8,6 +8,20 @@ def test_sentence_extra_is_available_for_install_scripts():
     assert '"sentence-transformers>=3"' in pyproject
 
 
+def test_benchmark_extra_installs_chroma():
+    pyproject = Path("pyproject.toml").read_text(encoding="utf-8")
+
+    assert "bench = [" in pyproject
+    assert '"chromadb>=1.0"' in pyproject
+
+
+def test_langchain_extra_installs_classic_memory_api():
+    pyproject = Path("pyproject.toml").read_text(encoding="utf-8")
+
+    assert "langchain = [" in pyproject
+    assert '"langchain-classic>=1.0"' in pyproject
+
+
 def test_install_scripts_create_venv_and_install_sentence_extra():
     install_sh = Path("install.sh").read_text(encoding="utf-8")
     install_bat = Path("install.bat").read_text(encoding="utf-8")

wavemind-2.0.1/wavemind/integrations/__init__.py

@@ -0,0 +1,2 @@
+"""Optional integrations for external agent frameworks."""
+

wavemind-2.0.1/wavemind/integrations/langchain.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from pydantic import ConfigDict
+
+from wavemind import WaveMind
+
+
+try:
+    from langchain_classic.base_memory import BaseMemory
+except ImportError:
+    try:
+        from langchain.schema import BaseMemory
+    except ImportError:
+
+        class BaseMemory:
+            """Small fallback so the integration can be imported without LangChain."""
+
+            def __init__(self, **data: Any):
+                for key, value in data.items():
+                    setattr(self, key, value)
+
+
+class WaveMindMemory(BaseMemory):
+    """LangChain BaseMemory implementation backed by WaveMind."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    memory: WaveMind
+    db_path: str | Path | None = None
+    memory_key: str = "history"
+    input_key: str | None = None
+    output_key: str | None = None
+    namespace: str = "langchain"
+    tags: tuple[str, ...] = ("langchain", "conversation")
+    top_k: int = 5
+    min_score: float | None = None
+    human_prefix: str = "Human"
+    ai_prefix: str = "AI"
+    include_scores: bool = False
+    max_context_chars: int = 4000
+
+    def __init__(self, **data: Any):
+        if data.get("memory") is None:
+            data["memory"] = WaveMind(db_path=data.get("db_path"))
+        if "tags" in data and data["tags"] is not None:
+            data["tags"] = tuple(data["tags"])
+        super().__init__(**data)
+
+    @property
+    def memory_variables(self) -> list[str]:
+        return [self.memory_key]
+
+    def load_memory_variables(self, inputs: dict[str, Any]) -> dict[str, Any]:
+        query = self._select_input_text(inputs, allow_empty=True)
+        if not query:
+            return {self.memory_key: ""}
+
+        results = self.memory.query(
+            query,
+            namespace=self.namespace,
+            tags=self.tags,
+            top_k=self.top_k,
+            min_score=self.min_score,
+        )
+        lines = []
+        for index, result in enumerate(results, start=1):
+            prefix = f"[{index}]"
+            if self.include_scores:
+                prefix = f"{prefix} ({result.score:.2f})"
+            lines.append(f"{prefix} {result.text}")
+        return {self.memory_key: self._truncate("\n".join(lines))}
+
+    def save_context(self, inputs: dict[str, Any], outputs: dict[str, str]) -> None:
+        input_text = self._select_input_text(inputs)
+        output_text = self._select_output_text(outputs)
+        turn = f"{self.human_prefix}: {input_text}\n{self.ai_prefix}: {output_text}"
+        self.memory.remember(
+            turn,
+            namespace=self.namespace,
+            tags=self.tags,
+            metadata={
+                "kind": "langchain_conversation_turn",
+                "input": input_text,
+                "output": output_text,
+            },
+            priority=1.2,
+        )
+
+    def clear(self) -> None:
+        self.memory.forget(namespace=self.namespace)
+
+    def _select_input_text(self, inputs: dict[str, Any], allow_empty: bool = False) -> str:
+        if self.input_key is not None:
+            return self._stringify(inputs.get(self.input_key, ""))
+
+        candidate_keys = [key for key in inputs if key not in self.memory_variables]
+        for preferred in ("input", "question", "query", "prompt"):
+            if preferred in candidate_keys:
+                return self._stringify(inputs[preferred])
+
+        if len(candidate_keys) == 1:
+            return self._stringify(inputs[candidate_keys[0]])
+        if not candidate_keys and allow_empty:
+            return ""
+        raise ValueError(
+            "Could not infer the LangChain input key. Set input_key explicitly."
+        )
+
+    def _select_output_text(self, outputs: dict[str, Any]) -> str:
+        if self.output_key is not None:
+            return self._stringify(outputs.get(self.output_key, ""))
+
+        for preferred in ("output", "answer", "response", "text"):
+            if preferred in outputs:
+                return self._stringify(outputs[preferred])
+
+        if len(outputs) == 1:
+            return self._stringify(next(iter(outputs.values())))
+        raise ValueError(
+            "Could not infer the LangChain output key. Set output_key explicitly."
+        )
+
+    def _truncate(self, text: str) -> str:
+        if self.max_context_chars <= 0 or len(text) <= self.max_context_chars:
+            return text
+        return text[: self.max_context_chars].rstrip()
+
+    def _stringify(self, value: Any) -> str:
+        if value is None:
+            return ""
+        if isinstance(value, str):
+            return value
+        if hasattr(value, "content"):
+            return str(value.content)
+        if isinstance(value, (list, tuple)):
+            return "\n".join(self._stringify(item) for item in value)
+        if isinstance(value, dict):
+            return json.dumps(value, ensure_ascii=False, sort_keys=True)
+        return str(value)
+
+
+__all__ = ["WaveMindMemory"]

{wavemind-2.0.0 → wavemind-2.0.1}/wavemind.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavemind
-Version: 2.0.0
+Version: 2.0.1
 Summary: Persistent dynamic memory engine with vector search and wave-field re-ranking
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/CaspianG/wavemind
@@ -20,6 +20,10 @@ Requires-Dist: sentence-transformers>=3; extra == "ml"
 Provides-Extra: indexes
 Requires-Dist: annoy>=1.17; extra == "indexes"
 Requires-Dist: faiss-cpu>=1.8; platform_system != "Windows" and extra == "indexes"
+Provides-Extra: bench
+Requires-Dist: chromadb>=1.0; extra == "bench"
+Provides-Extra: langchain
+Requires-Dist: langchain-classic>=1.0; extra == "langchain"
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
 Requires-Dist: httpx>=0.27; extra == "dev"
@@ -73,6 +77,29 @@ sh install.sh
 install.bat
 ```
 
+## LangChain Memory
+
+Install the optional integration:
+
+```sh
+pip install "wavemind[langchain]"
+```
+
+Use WaveMind as a drop-in LangChain memory object:
+
+```python
+from wavemind.integrations.langchain import WaveMindMemory
+
+memory = WaveMindMemory(db_path="agent_memory.sqlite3")
+# Replace: memory = ConversationBufferMemory()
+```
+
+Offline runnable example:
+
+```sh
+python examples/langchain_memory.py
+```
+
 ## Benchmark
 
 Real Russian sentences from Tatoeba, 50 one-word queries, NumPy exact index.
@@ -98,6 +125,23 @@ python benchmarks/ru_sentences_benchmark.py --sentences 200 --queries 50 --encod
 python benchmarks/ru_sentences_benchmark.py --sentences 200 --queries 50 --encoder sentence --index numpy
 ```
 
+Agent-memory benchmark against Chroma:
+
+200 Russian user facts, 50 natural-language questions, same precomputed `HashingTextEncoder` embeddings for WaveMind and Chroma.
+Full machine-readable result: `benchmarks/agent_memory_results.json`.
+
+| engine | precision@1 | precision@3 | avg latency |
+|---|---:|---:|---:|
+| WaveMind | 0.82 | 0.90 | 2.25 ms |
+| Chroma | 0.82 | 0.88 | 0.93 ms |
+
+Run locally:
+
+```sh
+pip install -e ".[bench]"
+python benchmarks/agent_memory_benchmark.py --engines wavemind chroma --facts 200 --queries 50
+```
+
 ## Comparison
 
 | feature | WaveMind | Chroma | Qdrant |
@@ -118,12 +162,13 @@ WaveMind is not trying to replace dedicated vector databases at scale. Its diffe
 - At 5000 records, one-word `precision@1` is currently 0.72 with the hash encoder; many misses are ambiguous queries where another sentence containing the same word ranks first.
 - For `N > 5000`, use the FAISS backend with `--index faiss` or another production vector index.
 - `sentence-transformers/paraphrase-multilingual-mpnet-base-v2` requires about 420 MB of model files and measured about 53 ms per query on the benchmark machine.
-- The bundled benchmark is a retrieval sanity check, not a full agent-memory benchmark against Chroma or Qdrant yet.
+- The Chroma comparison currently uses shared precomputed hash embeddings to isolate retrieval/ranking behavior; semantic model comparisons should be run separately.
+- In the 200-fact agent benchmark, Chroma is faster on average while WaveMind is slightly higher at `precision@3`.
 
 ## Roadmap
 
 - FAISS-first production index path with persisted index rebuilds.
-- Larger public benchmark against Chroma and Qdrant on agent-memory tasks.
+- Expand the agent-memory benchmark to sentence-transformers, FAISS, Chroma default embeddings, and Qdrant.
 - Better semantic query expansion for short and ambiguous queries.
 - Namespace quotas, backups, and daemon hardening for SaaS use.
 - Webhook on recall for agent runtimes.

{wavemind-2.0.0 → wavemind-2.0.1}/wavemind.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 LICENSE
 README.md
 pyproject.toml
+tests/test_agent_memory_benchmark.py
 tests/test_api.py
 tests/test_api_process_persistence.py
 tests/test_cli_smoke.py
@@ -8,6 +9,7 @@ tests/test_core_persistence.py
 tests/test_examples.py
 tests/test_import_benchmark.py
 tests/test_indexes_encoders.py
+tests/test_langchain_integration.py
 tests/test_packaging_files.py
 tests/test_semantic_and_latency.py
 wavemind/__init__.py
@@ -25,4 +27,6 @@ wavemind.egg-info/SOURCES.txt
 wavemind.egg-info/dependency_links.txt
 wavemind.egg-info/entry_points.txt
 wavemind.egg-info/requires.txt
-wavemind.egg-info/top_level.txt
+wavemind.egg-info/top_level.txt
+wavemind/integrations/__init__.py
+wavemind/integrations/langchain.py

{wavemind-2.0.0 → wavemind-2.0.1}/wavemind.egg-info/requires.txt

@@ -4,6 +4,9 @@ uvicorn[standard]>=0.27
 pydantic>=2
 pypdf>=4
 
+[bench]
+chromadb>=1.0
+
 [dev]
 pytest>=8
 httpx>=0.27
@@ -14,6 +17,9 @@ annoy>=1.17
 [indexes:platform_system != "Windows"]
 faiss-cpu>=1.8
 
+[langchain]
+langchain-classic>=1.0
+
 [ml]
 sentence-transformers>=3