Metadata-Version: 2.4
Name: langgraph-agentram
Version: 0.1.0
Summary: AgentRAM-backed LangGraph BaseStore: hosted long-term memory for LangGraph agents, no vector database.
Project-URL: Homepage, https://agentram.dev
Project-URL: Repository, https://github.com/seanmarkwei/langgraph-agentram
Project-URL: Issues, https://github.com/seanmarkwei/langgraph-agentram/issues
Author: Sean Markwei
License: MIT
License-File: LICENSE
Keywords: agent-memory,agentram,basestore,langchain,langgraph,llm-memory,long-term-memory,memory
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Requires-Python: >=3.9
Requires-Dist: langgraph>=0.2.0
Description-Content-Type: text/markdown

# langgraph-agentram

An [AgentRAM](https://agentram.dev)-backed `BaseStore` for LangGraph. It gives your LangGraph agents cross-thread long-term memory through a hosted key-value API, with no vector database and no embedding pipeline to run.

LangGraph's long-term memory is built on stores: JSON values organized by a namespace and a key. AgentRAM is a hosted memory API with exactly that shape, so this adapter is a thin, honest bridge between the two.

## Install

```bash
pip install langgraph-agentram
```

Get a free AgentRAM API key at [agentram.dev](https://agentram.dev). New accounts start with 1,000 credits, no card required.

## Use it

Pass the store to your agent and it gains memory that survives across threads:

```python
from langchain.agents import create_agent
from langgraph_agentram import AgentRAMStore

store = AgentRAMStore(api_key="agentram_your_key_here")

agent = create_agent("claude-sonnet-4-6", tools=[], store=store)
```

Or use the store directly:

```python
store.put(("memories", "user-1"), "language", {"value": "French"})
item = store.get(("memories", "user-1"), "language")
print(item.value)  # {"value": "French"}

# list a namespace, or text-search within it
store.search(("memories", "user-1"))
store.search(("memories", "user-1"), query="French")
```

## How it maps to AgentRAM

- A namespace tuple becomes an AgentRAM `agent_id`, joined with `/` (for example `("memories", "user-1")` becomes `memories/user-1`).
- The key is the AgentRAM key.
- The value dict is JSON-encoded into AgentRAM's value field.

## Honest limits

This adapter does what AgentRAM does, and nothing it does not.

- `search` is a text match, not semantic ranking. `score` is always `None`. That is the point: memory without a vector database.
- `search` treats the namespace you pass as a full namespace, not a prefix to walk into nested sub-namespaces.
- `list_namespaces` is not supported. AgentRAM has no endpoint to enumerate namespaces, so the adapter raises rather than return a wrong answer. Track namespaces in your own app if you need them.
- A namespace maps to an `agent_id` capped at 100 characters, and a value is capped at 5,000 characters. Both raise a clear error if exceeded, rather than truncating.
- Per-item TTL is not mapped in this version.

## Config

- `api_key` (required): your key, starts with `agentram_`.
- `base_url` (optional): defaults to `https://api.agentram.dev`.

## Links

- AgentRAM: https://agentram.dev
- API docs: https://agentram.dev/docs.html
- Issues: https://github.com/seanmarkwei/langgraph-agentram/issues

MIT
