Voice
Yantrik Memory
By Your agent starts every conversation as a stranger. yantrik-memory is a framework-agnostic Python memory layer — hybrid recall, 9 evolving personality traits, bond progression, and a knowledge graph — on a single SQLite file. pip install yantrik-memory.
Install
pip install yantrik-memoryREADME
# Yantrik Memory
[](https://pypi.org/project/yantrik-memory/)
[](https://pypi.org/project/yantrik-memory/)
[](LICENSE)
Your agent starts every conversation as a stranger. It re-asks what stack you
use, forgets the preference you stated last week, and treats a two-year user
exactly like a first-time one.
Yantrik Memory is a framework-agnostic Python memory layer that fixes that:
one call per turn returns the memories, the personality traits the agent has
learned about *this* user, how far the relationship has progressed, and the
context an LLM needs to answer. Storage is a single SQLite file via
[YantrikDB](https://github.com/yantrikos/yantrikdb) ([docs](https://yantrikdb.com))
— no vector service, no external database, no API keys.
## Install (60 seconds)
```bash
pip install yantrik-memory
yantrik-memory init
```
```python
from yantrik_memory import YantrikMemory
mem = YantrikMemory()
context = mem.process_turn(
agent_id="assistant",
user_id="user123",
message="I prefer dark mode and concise answers",
)
print(context["traits"]) # {'conciseness': 0.55, 'humor': 0.5, ...}
print(context["bond"]["level"]) # 'acquaintance'
print(context["memories"]) # what this user told you before
```
That is the whole integration: one `process_turn` call per user message, and
the returned dict carries memories, traits, bond state, personality guidance,
mood and intent. Works with any agent framework — it never sees your LLM.
## What it does
Gives your AI agent persistent memory that survives across conversations:
- **Remember & Recall** — Store and retrieve memories with hybrid search (semantic + graph + temporal + keyword)
- **Personality Traits** — 9 evolving traits that adapt to each user
- **Bond Evolution** — Relationships grow from stranger to bonded over time
- **Knowledge Graph** — Entity relationships for context-aware retrieval
- **Context Assembly** — One call to get everything an LLM needs
## Real Conversation Demo
Here's Yantrik Memory running inside [OpenClaw](https://github.com/openclaw/openclaw) — an open-source AI agent platform. The agent remembers context across turns, learns preferences, and builds a profile over time.
**Turn 1** — Alex introduces himself:
> **Alex:** Hey! I'm Alex. I'm a backend engineer at a startup. We're building a task management app and I need help setting up the API.
> **Agent:** Hi Alex. What stack are you using? What API help do you need?
**Turn 2** — Alex shares preferences, agent adapts:
> **Alex:** We're using Python with FastAPI. I prefer keeping things simple — no over-engineering. Can you suggest a basic project structure?
> **Agent:**
> ```
> taskapp/
> ├── app/
> │ ├── main.py # FastAPI app
> │ ├── api/
> │ │ ├── tasks.py # /tasks endpoints
> │ │ └── users.py # /users endpoints
> │ ├── core/
> │ │ ├── config.py # Settings
> │ │ └── security.py # Auth utils
> │ ├── models/
> │ │ ├── task.py # Pydantic models
> │ │ └── user.py
> │ └── db/
> │ └── database.py # DB connection
> ├── requirements.txt
> └── README.md
> ```
**Turn 3** — Agent remembers the database preference:
> **Alex:** That's perfect, thanks! Oh and remember — I always use PostgreSQL for production and SQLite for local dev. What about the database layer?
> **Agent:**
> ```python
> from sqlalchemy import create_engine
> from sqlalchemy.orm import sessionmaker
> from app.core.config import settings
>
> # Use SQLite for dev, PostgreSQL for prod
> engine = create_engine(settings.DATABASE_URL)
> SessionLocal = sessionmaker(bind=engine)
> ```
**Turn 4** — Alex asks what the agent remembers:
> **Alex:** Great work! You're really helpful. One more thing — what do you remember about me and my project so far?
> **Agent:**
> - Backend engineer at a startup
> - Building a task management app
> - Using Python with FastAPI
> - Prefer simple solutions, no over-engineering
> - Always use PostgreSQL for production, SQLite for local dev
Behind the scenes, Yantrik Memory tracked:
- **Traits evolved:** `helpfulness: 0.55` (from "really helpful"), `conciseness: 0.55` (from "keeping things simple")
- **Bond level:** `acquaintance` (score: 0.08 after 4 interactions)
- **Memories stored:** 5 facts about Alex, preferences, and project context
- **Knowledge graph:** `Alex → works_at → Startup`, `TaskApp → uses → FastAPI`
## OpenClaw / ClawDBot Plugin
Yantrik Memory is a ClawHub plugin. Install via:
```bash
openclaw plugins install yantrik-memory
```
Or add to your skills directory:
```bash
cd ~/.openclaw/skills
git clone https://github.com/yantrikos/yantrik-memory.git
pip install -e yantrik-memory
```
## Powered by [YantrikDB](https://github.com/yantrikos/yantrikdb)
5 unified indexes on a single SQLite file:
| Index | Purpose |
|-------|---------|
| Vector (HNSW) | Semantic similarity |
| Graph | Entity relationships |
| Temporal | Time-aware retrieval |
| Decay Heap | Memory lifecycle |
| KV | Fast lookups |
<60ms latency. Zero config. No external databases.
## Related projects
Part of a portfolio of agent infrastructure built by one person, designed to
be used together:
- [yantrikdb](https://github.com/yantrikos/yantrikdb) — the cognitive memory
engine underneath: Rust core, Python bindings, temporal decay, contradiction
detection.
- [yantrikdb-server](https://github.com/yantrikos/yantrikdb-server) — the same
engine as an HTTP service / cluster when several agents share one memory.
- [yantrikdb-mcp](https://github.com/yantrikos/yantrikdb-mcp) — that memory as
an MCP server for Claude Code, Cursor and Windsurf.
- [langchain-yantrikdb](https://github.com/yantrikos/langchain-yantrikdb) — the
same memory as a LangChain `VectorStore` and `ChatMessageHistory`.
- [openclaw-memory-yantrikdb](https://github.com/yantrikos/openclaw-memory-yantrikdb)
— OpenClaw memory-slot plugin backed by the same engine.
## License
MIT
voice
Comments
Sign in to leave a comment