langchain-membase 0.1.0__tar.gz

langchain_membase-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+.venv/
+__pycache__/
+*.egg-info/
+dist/
+build/
+node_modules/
+.pytest_cache/
+.ruff_cache/
+*.difypkg
+.env
+# Submission notes stay with the maintainers, not in the published repo.
+SUBMISSION.md
+CONVENTIONS.md

langchain_membase-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Unibase
+
+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_membase-0.1.0/PKG-INFO

@@ -0,0 +1,211 @@
+Metadata-Version: 2.5
+Name: langchain-membase
+Version: 0.1.0
+Summary: Membase long-term memory for LangChain and LangGraph: a retriever, agent tools and a recall middleware.
+Project-URL: Homepage, https://membase.com
+Project-URL: Documentation, https://github.com/unibaseio/membase/tree/main/integrations/langchain#readme
+Project-URL: Repository, https://github.com/unibaseio/membase
+Project-URL: Issues, https://github.com/unibaseio/membase/issues
+Author: Unibase
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,langchain,langgraph,membase,memory,retriever
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+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 :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: langchain-core<2,>=1.0
+Requires-Dist: unibaseio-membase>=0.3.2
+Provides-Extra: agents
+Requires-Dist: langchain<2,>=1.1; extra == 'agents'
+Description-Content-Type: text/markdown
+
+# langchain-membase
+
+[Membase](https://membase.com) long-term memory for LangChain and LangGraph (Python).
+
+Membase keeps a person's memory in their own account: named **Memories** (containers) that
+learn from their notes, files and conversations, plus a **profile** of standing facts. This
+package gives a LangChain app three ways to use it:
+
+| Piece | LangChain type | What it does |
+|---|---|---|
+| `MembaseRetriever` | `BaseRetriever` | a Membase search as `Document`s, each citing its Memory in `metadata["container_name"]` |
+| `MembaseToolkit` (`membase_tools()`): `MembaseSearchTool`, `MembaseSaveTool`, `MembaseProfileTool` | `BaseToolkit` / `BaseTool` | agent tools: search, save (only when the user asks), read the profile |
+| `MembaseRecallMiddleware` | LangChain v1 `AgentMiddleware` | time-boxed recall added to the system message before the model call of a `create_agent` agent |
+
+There is deliberately **no delete or forget tool**, and the package never confirms a
+destructive action. It also does not implement LangGraph's `BaseStore`: Membase is a memory
+that learns, not a key-value store (there is no get-by-key), so it is offered as retrieval and
+tools instead.
+
+## Install
+
+```bash
+pip install langchain-membase             # retriever + tools (needs langchain-core)
+pip install 'langchain-membase[agents]'   # + the create_agent middleware (needs langchain>=1.1)
+```
+
+Python 3.10+. Get a key in the Membase app under **Connect › Developer keys** and set it:
+
+```bash
+export MEMBASE_API_KEY=mbk_...
+```
+
+A **Read** key can search and read the profile (if its owner ticked it); saving needs a
+**Read & write** key. One key is one person's account.
+
+## Retriever
+
+```python
+from langchain_membase import MembaseRetriever
+
+retriever = MembaseRetriever(k=5)                     # MEMBASE_API_KEY from the environment
+docs = retriever.invoke("what did we decide about the ledger")
+for d in docs:
+    print(d.metadata["container_name"], "·", d.page_content)
+```
+
+* `k` (1–50) is the number of passages in all; unset lets Membase cover every Memory in reach.
+* `container="mv-…"` limits the search to one Memory (its id from `client.containers.list()`).
+  Both can also be passed per call: `retriever.invoke(q, k=3, container="mv-…")`.
+* If no passage comes back **and** some Memory could not answer (no model, dormant), the
+  retriever raises `MembaseUnavailableError` instead of returning `[]`: that is not evidence of
+  "no memory". When some Memories answered, it returns their passages and logs the rest.
+* A `403` (`membase.PermissionDeniedError`) means the key's owner narrowed or revoked it; do
+  not retry with that key.
+
+It works anywhere a retriever does, e.g. in an LCEL chain:
+
+```python
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.runnables import RunnablePassthrough
+
+def cite(docs):
+    return "\n".join(f"[{d.metadata['container_name']}] {d.page_content}" for d in docs)
+
+prompt = ChatPromptTemplate.from_template("Memory:\n{memory}\n\nQuestion: {question}")
+chain = {"memory": retriever | cite, "question": RunnablePassthrough()} | prompt | llm
+```
+
+## Agent tools
+
+```python
+from langchain.agents import create_agent
+from langchain_membase import MembaseToolkit
+
+agent = create_agent("openai:gpt-5", tools=MembaseToolkit().get_tools())   # or membase_tools()
+agent.invoke({"messages": [{"role": "user", "content": "What did we pick for the ledger?"}]})
+```
+
+| Tool | Arguments | Notes |
+|---|---|---|
+| `membase_search` | `query`, optional `container` (a Memory's **name**) | passages as `- [Memory name] text`; the raw response is the `ToolMessage` artifact; Memories that could not answer are reported |
+| `membase_save` | `content` (the user's words), `static`, optional `container` | the description tells the model to save **only when the user asks**; `static=true` records a standing fact in the profile; with several Memories in reach it needs a `container` (or a default `container=` id on the tool) and says which names exist |
+| `membase_profile` | optional `topic` | standing and recently changed facts; only for a key whose owner ticked the profile |
+
+`MembaseToolkit(save=False, profile=False)` (or `membase_tools(client, save=False, profile=False)`) leaves tools out; `container=` and `k=` set
+defaults. Errors come back as the tool's answer (`handle_tool_error=True`), so the model can
+tell the user, e.g. "this Membase key was narrowed or revoked".
+
+Explicit tool calls use the SDK's own timeout (90 s): the first search after a quiet spell
+takes longer while the user's memory wakes.
+
+## Recall middleware (LangChain v1)
+
+```python
+from langchain.agents import create_agent
+from langchain_membase import MembaseRecallMiddleware, membase_tools
+
+agent = create_agent(
+    "openai:gpt-5",
+    tools=membase_tools(),
+    system_prompt="You are a helpful assistant.",
+    middleware=[MembaseRecallMiddleware(k=5, timeout=8.0)],
+)
+```
+
+Before the model call, the middleware searches Membase for the latest user message and appends
+the passages (each with its Memory) to the system message of that request.
+
+* **Time-boxed and fail-open**: it waits at most `timeout` seconds (8 by default). On a timeout,
+  a `403` or any other error it logs a warning on the `langchain_membase` logger and the model
+  runs without memory. A search that ran past the budget finishes in the background, which
+  wakes the memory for the next turn.
+* **Once per user message**: model calls that follow tool calls in the same turn reuse the
+  result.
+* **Nothing is persisted**: the recall lives in the model request only, never in the agent's
+  state or checkpoint.
+* **No automatic writes by default**. `capture_turns=True` (opt-in) saves the user's own
+  message(s) of each turn, once, as a note in `container=`, in the background. Assistant
+  replies are never saved, so an AI answer is not learned as a fact about the user.
+
+## Many users
+
+A Membase key belongs to one person, so a multi-user app holds one key (or one local
+directory) **per end user** and passes `client_for`, a function from user id to that user's
+client. Every class and `membase_tools()` accept it. The user id is read from the run:
+
+```python
+from functools import lru_cache
+from membase import Membase
+from langchain_membase import MembaseRecallMiddleware, MembaseRetriever, membase_tools
+
+@lru_cache(maxsize=1024)            # reuse each user's client (and its connection pool)
+def client_for(user_id: str) -> Membase:
+    return Membase(api_key=load_user_key(user_id))   # that user's key, never another's
+
+retriever = MembaseRetriever(client_for=client_for)
+retriever.invoke("...", config={"configurable": {"user_id": "alice"}})
+
+agent = create_agent(
+    model,
+    tools=membase_tools(client_for=client_for),
+    middleware=[MembaseRecallMiddleware(client_for=client_for)],
+)
+agent.invoke({"messages": [...]}, config={"configurable": {"user_id": "alice"}})
+```
+
+The user id is taken from `config["configurable"]["user_id"]`, or from a LangGraph run
+context with a `user_id` field (`create_agent(..., context_schema=Ctx)` and
+`agent.invoke(..., context=Ctx(user_id="alice"))`). With `client_for` set, a call that carries
+no user id raises `MissingUserIdError` (the middleware logs it and skips recall); it never
+falls back to another client. `client_for` and `client`/`api_key`/`local` are mutually
+exclusive.
+
+**Without `client_for`, one client serves every call.** That suits a personal agent (your own
+key, your own memory), not a multi-user app.
+
+Local mode keeps each person in their own directory:
+`client_for=lambda uid: Membase(local=f"/data/membase/{uid}")`
+(`pip install 'unibaseio-membase[local]'`, Python 3.12+, and an LLM key such as
+`OPENAI_API_KEY`).
+
+## Configuration
+
+Every class takes `client=Membase(...)`, or `api_key=` / `base_url=` / `local=`; otherwise
+`MEMBASE_API_KEY` and `MEMBASE_BASE_URL` come from the environment. The API host defaults to
+`https://api.app.membase.com`.
+
+## Development
+
+```bash
+uv venv .venv && uv pip install --python .venv/bin/python -e . \
+  'langchain>=1.1' langgraph langchain-tests pytest pytest-asyncio ruff
+.venv/bin/python -m pytest              # offline: the real SDK over httpx.MockTransport
+MEMBASE_API_KEY=mbk_... .venv/bin/python examples/live_smoke.py   # against the real API
+uv build
+```
+
+The offline suite includes LangChain's standard tests (`langchain-tests`) for the retriever
+and the three tools, and runs the tools and the middleware inside a real `create_agent`
+(LangGraph) graph with a scripted chat model.
+
+## Licence
+
+MIT

langchain_membase-0.1.0/README.md

@@ -0,0 +1,184 @@
+# langchain-membase
+
+[Membase](https://membase.com) long-term memory for LangChain and LangGraph (Python).
+
+Membase keeps a person's memory in their own account: named **Memories** (containers) that
+learn from their notes, files and conversations, plus a **profile** of standing facts. This
+package gives a LangChain app three ways to use it:
+
+| Piece | LangChain type | What it does |
+|---|---|---|
+| `MembaseRetriever` | `BaseRetriever` | a Membase search as `Document`s, each citing its Memory in `metadata["container_name"]` |
+| `MembaseToolkit` (`membase_tools()`): `MembaseSearchTool`, `MembaseSaveTool`, `MembaseProfileTool` | `BaseToolkit` / `BaseTool` | agent tools: search, save (only when the user asks), read the profile |
+| `MembaseRecallMiddleware` | LangChain v1 `AgentMiddleware` | time-boxed recall added to the system message before the model call of a `create_agent` agent |
+
+There is deliberately **no delete or forget tool**, and the package never confirms a
+destructive action. It also does not implement LangGraph's `BaseStore`: Membase is a memory
+that learns, not a key-value store (there is no get-by-key), so it is offered as retrieval and
+tools instead.
+
+## Install
+
+```bash
+pip install langchain-membase             # retriever + tools (needs langchain-core)
+pip install 'langchain-membase[agents]'   # + the create_agent middleware (needs langchain>=1.1)
+```
+
+Python 3.10+. Get a key in the Membase app under **Connect › Developer keys** and set it:
+
+```bash
+export MEMBASE_API_KEY=mbk_...
+```
+
+A **Read** key can search and read the profile (if its owner ticked it); saving needs a
+**Read & write** key. One key is one person's account.
+
+## Retriever
+
+```python
+from langchain_membase import MembaseRetriever
+
+retriever = MembaseRetriever(k=5)                     # MEMBASE_API_KEY from the environment
+docs = retriever.invoke("what did we decide about the ledger")
+for d in docs:
+    print(d.metadata["container_name"], "·", d.page_content)
+```
+
+* `k` (1–50) is the number of passages in all; unset lets Membase cover every Memory in reach.
+* `container="mv-…"` limits the search to one Memory (its id from `client.containers.list()`).
+  Both can also be passed per call: `retriever.invoke(q, k=3, container="mv-…")`.
+* If no passage comes back **and** some Memory could not answer (no model, dormant), the
+  retriever raises `MembaseUnavailableError` instead of returning `[]`: that is not evidence of
+  "no memory". When some Memories answered, it returns their passages and logs the rest.
+* A `403` (`membase.PermissionDeniedError`) means the key's owner narrowed or revoked it; do
+  not retry with that key.
+
+It works anywhere a retriever does, e.g. in an LCEL chain:
+
+```python
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.runnables import RunnablePassthrough
+
+def cite(docs):
+    return "\n".join(f"[{d.metadata['container_name']}] {d.page_content}" for d in docs)
+
+prompt = ChatPromptTemplate.from_template("Memory:\n{memory}\n\nQuestion: {question}")
+chain = {"memory": retriever | cite, "question": RunnablePassthrough()} | prompt | llm
+```
+
+## Agent tools
+
+```python
+from langchain.agents import create_agent
+from langchain_membase import MembaseToolkit
+
+agent = create_agent("openai:gpt-5", tools=MembaseToolkit().get_tools())   # or membase_tools()
+agent.invoke({"messages": [{"role": "user", "content": "What did we pick for the ledger?"}]})
+```
+
+| Tool | Arguments | Notes |
+|---|---|---|
+| `membase_search` | `query`, optional `container` (a Memory's **name**) | passages as `- [Memory name] text`; the raw response is the `ToolMessage` artifact; Memories that could not answer are reported |
+| `membase_save` | `content` (the user's words), `static`, optional `container` | the description tells the model to save **only when the user asks**; `static=true` records a standing fact in the profile; with several Memories in reach it needs a `container` (or a default `container=` id on the tool) and says which names exist |
+| `membase_profile` | optional `topic` | standing and recently changed facts; only for a key whose owner ticked the profile |
+
+`MembaseToolkit(save=False, profile=False)` (or `membase_tools(client, save=False, profile=False)`) leaves tools out; `container=` and `k=` set
+defaults. Errors come back as the tool's answer (`handle_tool_error=True`), so the model can
+tell the user, e.g. "this Membase key was narrowed or revoked".
+
+Explicit tool calls use the SDK's own timeout (90 s): the first search after a quiet spell
+takes longer while the user's memory wakes.
+
+## Recall middleware (LangChain v1)
+
+```python
+from langchain.agents import create_agent
+from langchain_membase import MembaseRecallMiddleware, membase_tools
+
+agent = create_agent(
+    "openai:gpt-5",
+    tools=membase_tools(),
+    system_prompt="You are a helpful assistant.",
+    middleware=[MembaseRecallMiddleware(k=5, timeout=8.0)],
+)
+```
+
+Before the model call, the middleware searches Membase for the latest user message and appends
+the passages (each with its Memory) to the system message of that request.
+
+* **Time-boxed and fail-open**: it waits at most `timeout` seconds (8 by default). On a timeout,
+  a `403` or any other error it logs a warning on the `langchain_membase` logger and the model
+  runs without memory. A search that ran past the budget finishes in the background, which
+  wakes the memory for the next turn.
+* **Once per user message**: model calls that follow tool calls in the same turn reuse the
+  result.
+* **Nothing is persisted**: the recall lives in the model request only, never in the agent's
+  state or checkpoint.
+* **No automatic writes by default**. `capture_turns=True` (opt-in) saves the user's own
+  message(s) of each turn, once, as a note in `container=`, in the background. Assistant
+  replies are never saved, so an AI answer is not learned as a fact about the user.
+
+## Many users
+
+A Membase key belongs to one person, so a multi-user app holds one key (or one local
+directory) **per end user** and passes `client_for`, a function from user id to that user's
+client. Every class and `membase_tools()` accept it. The user id is read from the run:
+
+```python
+from functools import lru_cache
+from membase import Membase
+from langchain_membase import MembaseRecallMiddleware, MembaseRetriever, membase_tools
+
+@lru_cache(maxsize=1024)            # reuse each user's client (and its connection pool)
+def client_for(user_id: str) -> Membase:
+    return Membase(api_key=load_user_key(user_id))   # that user's key, never another's
+
+retriever = MembaseRetriever(client_for=client_for)
+retriever.invoke("...", config={"configurable": {"user_id": "alice"}})
+
+agent = create_agent(
+    model,
+    tools=membase_tools(client_for=client_for),
+    middleware=[MembaseRecallMiddleware(client_for=client_for)],
+)
+agent.invoke({"messages": [...]}, config={"configurable": {"user_id": "alice"}})
+```
+
+The user id is taken from `config["configurable"]["user_id"]`, or from a LangGraph run
+context with a `user_id` field (`create_agent(..., context_schema=Ctx)` and
+`agent.invoke(..., context=Ctx(user_id="alice"))`). With `client_for` set, a call that carries
+no user id raises `MissingUserIdError` (the middleware logs it and skips recall); it never
+falls back to another client. `client_for` and `client`/`api_key`/`local` are mutually
+exclusive.
+
+**Without `client_for`, one client serves every call.** That suits a personal agent (your own
+key, your own memory), not a multi-user app.
+
+Local mode keeps each person in their own directory:
+`client_for=lambda uid: Membase(local=f"/data/membase/{uid}")`
+(`pip install 'unibaseio-membase[local]'`, Python 3.12+, and an LLM key such as
+`OPENAI_API_KEY`).
+
+## Configuration
+
+Every class takes `client=Membase(...)`, or `api_key=` / `base_url=` / `local=`; otherwise
+`MEMBASE_API_KEY` and `MEMBASE_BASE_URL` come from the environment. The API host defaults to
+`https://api.app.membase.com`.
+
+## Development
+
+```bash
+uv venv .venv && uv pip install --python .venv/bin/python -e . \
+  'langchain>=1.1' langgraph langchain-tests pytest pytest-asyncio ruff
+.venv/bin/python -m pytest              # offline: the real SDK over httpx.MockTransport
+MEMBASE_API_KEY=mbk_... .venv/bin/python examples/live_smoke.py   # against the real API
+uv build
+```
+
+The offline suite includes LangChain's standard tests (`langchain-tests`) for the retriever
+and the three tools, and runs the tools and the middleware inside a real `create_agent`
+(LangGraph) graph with a scripted chat model.
+
+## Licence
+
+MIT

langchain_membase-0.1.0/examples/live_smoke.py

@@ -0,0 +1,108 @@
+"""Live smoke test against the real Membase API.
+
+    MEMBASE_API_KEY=mbk_... python examples/live_smoke.py
+
+Reads only, unless MEMBASE_SMOKE_WRITE=1 (then it saves one clearly labelled note through the
+save tool; that needs a Read & write key, and a container id in MEMBASE_SMOKE_CONTAINER when
+the key reaches several Memories). Without MEMBASE_API_KEY it says so and exits 0.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import sys
+import time
+from datetime import datetime, timezone
+
+from membase import Membase
+from membase.errors import PermissionDeniedError
+
+from langchain_membase import MembaseRetriever, membase_tools
+from langchain_membase._common import DEFAULT_BASE_URL
+
+QUERY = os.environ.get("MEMBASE_SMOKE_QUERY", "what do you know about me")
+
+
+def main() -> int:
+    if not os.environ.get("MEMBASE_API_KEY"):
+        print("MEMBASE_API_KEY is not set; skipping the live smoke test.")
+        return 0
+    logging.basicConfig(level=logging.WARNING)
+    # MEMBASE_API_KEY from the environment; the package's default host unless MEMBASE_BASE_URL.
+    client = Membase(base_url=os.environ.get("MEMBASE_BASE_URL") or DEFAULT_BASE_URL)
+    print("base url:", client.base_url)
+
+    containers = client.containers.list()["containers"]
+    print(f"containers in reach: {[c['name'] for c in containers]}")
+
+    t = time.monotonic()
+    docs = MembaseRetriever(client=client, k=5).invoke(QUERY)
+    print(f"retriever: {len(docs)} documents in {time.monotonic() - t:.1f}s")
+    for d in docs:
+        print(f"  [{d.metadata['container_name']}] {d.page_content[:100]!r}")
+
+    search, save, profile = membase_tools(client)
+    msg = search.invoke(
+        {"type": "tool_call", "name": search.name, "args": {"query": QUERY}, "id": "smoke-1"}
+    )
+    print("search tool:\n" + msg.content[:600])
+
+    msg = profile.invoke({"type": "tool_call", "name": profile.name, "args": {}, "id": "smoke-2"})
+    print("profile tool:\n" + msg.content[:600])
+
+    try:
+        from langchain.agents import create_agent  # noqa: F401
+
+        _middleware_smoke(client)
+    except ImportError:
+        print("middleware: skipped (pip install 'langchain-membase[agents]')")
+
+    if os.environ.get("MEMBASE_SMOKE_WRITE") == "1":
+        stamp = datetime.now(timezone.utc).isoformat(timespec="seconds")
+        args = {"content": f"langchain-membase live smoke note, {stamp}."}
+        if os.environ.get("MEMBASE_SMOKE_CONTAINER"):
+            args["container"] = os.environ["MEMBASE_SMOKE_CONTAINER"]
+        msg = save.invoke({"type": "tool_call", "name": save.name, "args": args, "id": "smoke-3"})
+        print("save tool:", msg.content)
+    else:
+        print("save tool: skipped (set MEMBASE_SMOKE_WRITE=1 to write one note)")
+    return 0
+
+
+def _middleware_smoke(client: Membase) -> None:
+    from langchain.agents import create_agent
+    from langchain_core.language_models import BaseChatModel
+    from langchain_core.messages import AIMessage, SystemMessage
+    from langchain_core.outputs import ChatGeneration, ChatResult
+
+    from langchain_membase import MembaseRecallMiddleware
+
+    seen: list[str] = []
+
+    class Echo(BaseChatModel):
+        def _generate(self, messages, stop=None, run_manager=None, **kwargs):
+            seen.append("\n".join(m.text for m in messages if isinstance(m, SystemMessage)))
+            return ChatResult(generations=[ChatGeneration(message=AIMessage(content="ok"))])
+
+        @property
+        def _llm_type(self) -> str:
+            return "echo"
+
+    timeout = float(os.environ.get("MEMBASE_SMOKE_RECALL_TIMEOUT", "8"))
+    agent = create_agent(Echo(), middleware=[MembaseRecallMiddleware(client, timeout=timeout)])
+    t = time.monotonic()
+    agent.invoke({"messages": [{"role": "user", "content": QUERY}]})
+    injected = "From the user's memory" in seen[0]
+    print(
+        f"middleware: recall injected={injected} in {time.monotonic() - t:.1f}s "
+        f"(budget {timeout:g}s; a cold memory may need a second run)"
+    )
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except PermissionDeniedError as e:
+        print(f"403: this Membase key was narrowed or revoked: {e}")
+        sys.exit(1)

langchain_membase-0.1.0/pyproject.toml

@@ -0,0 +1,66 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "langchain-membase"
+version = "0.1.0"
+description = "Membase long-term memory for LangChain and LangGraph: a retriever, agent tools and a recall middleware."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [{ name = "Unibase" }]
+keywords = ["langchain", "langgraph", "memory", "membase", "retriever", "agents"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "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 :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "unibaseio-membase>=0.3.2",
+    "langchain-core>=1.0,<2",
+]
+
+[project.optional-dependencies]
+# MembaseRecallMiddleware plugs into `langchain.agents.create_agent` (LangChain v1).
+agents = ["langchain>=1.1,<2"]
+
+[project.urls]
+Homepage = "https://membase.com"
+Documentation = "https://github.com/unibaseio/membase/tree/main/integrations/langchain#readme"
+Repository = "https://github.com/unibaseio/membase"
+Issues = "https://github.com/unibaseio/membase/issues"
+
+[dependency-groups]
+test = [
+    "langchain>=1.1,<2",
+    "langgraph>=1.0",
+    "langchain-tests>=1.0",
+    "pytest>=8",
+    "pytest-asyncio>=0.23",
+]
+lint = ["ruff>=0.6"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/langchain_membase"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/langchain_membase", "tests", "examples", "README.md", "LICENSE", "pyproject.toml"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+addopts = "--strict-markers"
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]

langchain_membase-0.1.0/src/langchain_membase/__init__.py

@@ -0,0 +1,49 @@
+"""Membase long-term memory for LangChain and LangGraph."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from ._common import DEFAULT_RECALL_TIMEOUT, MissingUserIdError
+from .retrievers import MembaseRetriever, MembaseUnavailableError
+from .tools import (
+    MembaseProfileTool,
+    MembaseSaveTool,
+    MembaseSearchTool,
+    MembaseToolkit,
+    membase_tools,
+)
+
+if TYPE_CHECKING:
+    from .middleware import MembaseRecallMiddleware
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "DEFAULT_RECALL_TIMEOUT",
+    "MembaseProfileTool",
+    "MembaseRecallMiddleware",
+    "MembaseRetriever",
+    "MembaseSaveTool",
+    "MembaseSearchTool",
+    "MembaseToolkit",
+    "MembaseUnavailableError",
+    "MissingUserIdError",
+    "membase_tools",
+    "__version__",
+]
+
+
+def __getattr__(name: str) -> Any:
+    # The middleware needs `langchain` (the `agents` extra); importing the package must not.
+    if name == "MembaseRecallMiddleware":
+        try:
+            from .middleware import MembaseRecallMiddleware
+        except ImportError as e:
+            raise ImportError(
+                "MembaseRecallMiddleware needs LangChain v1: "
+                "pip install 'langchain-membase[agents]'"
+            ) from e
+
+        return MembaseRecallMiddleware
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")