For developers

Three lines of code. Persistent AI memory.

You've built the hard parts: the reasoning, the tools, the orchestration. Memory is the one piece you shouldn't have to build from scratch. Store a memory. Search it later. That's the API. The 3-tier architecture, 5-layer search, knowledge graph, and self-improving retrieval all run on their own.

$pip install hebbrix
two ways in

Pick the integration that fits your architecture

Both paths give you the full memory stack. The difference is where you want control.

Path 1 · SDK

Full control

Explicit store and search calls. Use this when you want to decide exactly when memory is written and read: after a tool call, before a chain step, or on a webhook trigger.

sdk-approach.py
from hebbrix import MemoryClient

async with MemoryClient(api_key="YOUR_API_KEY") as mem:
    # Store something your agent learned
    await mem.memories.create(
        content="User prefers Python, concise answers",
        collection_id="user-alex-123"
    )

    # Retrieve relevant context before a call
    results = await mem.search(
        "user preferences",
        collection_id="user-alex-123"
    )
# Knowledge graph, 5-layer search,
# and auto-RL happen behind the scenes.
Path 2 · Drop-in

Zero changes

Point your OpenAI SDK at Hebbrix. Memory search and injection happen automatically before every LLM call. Your agent code stays exactly as-is.

drop-in-approach.py
import openai

# Change two lines. Keep everything else.
client = openai.OpenAI(
    base_url="https://api.hebbrix.com/v1",
    api_key="your_hebbrix_key"
)

response = client.chat.completions.create(
    model="gpt-4",
    messages=[{
        "role": "user",
        "content": "What are my preferences?"
    }]
)
# Hebbrix searched memories and injected
# context before forwarding to GPT-4.
what ships by default

Every feature works on its own. No configuration.

You call two methods. Everything else is running in the background.

3-tier memory

Short, medium, long-term. Promotes based on access frequency. Decays following the Ebbinghaus forgetting curve. No manual management.

5-layer hybrid search

Semantic vectors + BM25 + knowledge graph + importance + recency. All five run in parallel. One API call, sub-second response.

Knowledge graph

Entity and relationship extraction on every memory you store. Zero schema to define. Query connections with mem.graph.search().

Self-improving RL

6 quality checks run after every interaction. Helpful memories get reinforced. Noise fades. Your agent improves over time without any code changes.

Multi-tenancy

Collections isolate memory per user, per team, per project. One API, unlimited scopes. Maps cleanly to any data model you already have.

Natural decay

Old, irrelevant memories fade naturally. Context stays clean at production scale. Combine with explicit retention policies for compliance use cases.

Two API calls sitting on top of the 3-tier store, 5-layer search, knowledge graph, and RL loop
developer experience

Everything your toolchain already expects

Python SDK

Async-ready, type-safe, auto-retry. pip install hebbrix.

TypeScript SDK

Full type coverage. Works with Node, Deno, Bun. npm i hebbrix.

OpenAI drop-in

Same SDK, same types, same streaming. Change the URL.

REST API

160+ endpoints. Works from any language or tool.

MCP server

Claude Desktop, Cline, Cursor. Setup in 5 minutes.

LangChain

Drop-in or SDK. Works with any chain, any retriever.

LangGraph

Memory in graph state. Persists across runs.

CrewAI + Dify

Shared crew memory. Visual workflow HTTP nodes.

The Hebbrix developer dashboard with an API key, a live request log, and a memory browser

Start building in five minutes

Free tier, no credit card. 1,000 credits a month to build and evaluate. pip install and go.