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. Versioned memory, adaptive retrieval, temporal graph, and explicit Outcome Memory are available through one platform.

$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
import asyncio
import os
from hebbrix import MemoryClient

async def main():
    async with MemoryClient(api_key=os.environ["HEBBRIX_API_KEY"]) as memory:
        collection = await memory.collections.create(name="example-preferences")
        receipt = await memory.memories.create(
            collection_id=collection["id"],
            content="The user prefers concise Python examples.",
            wait_for_index=True,
        )
        if receipt.get("searchable") is not True:
            raise RuntimeError("Indexing is not confirmed; do not assume read readiness.")
        evidence = await memory.search(
            query="preferred examples", collection_id=collection["id"]
        )
        print(evidence)

if __name__ == "__main__":
    asyncio.run(main())
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.

Versioned memory

Current truth, superseded history, provenance, operational lifecycle tiers, retention controls, and explicit deletion.

Adaptive hybrid search

Dense + sparse + graph + temporal + facet + calibrated ranking signals. One API call with confidence and fallback metadata.

Knowledge graph

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

Outcome Memory

Record decision receipts and propensity, then report delayed outcomes. Inspect posterior evidence and uncertainty before changing behavior.

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.

API calls over versioned memory, adaptive retrieval, temporal graph evidence, and explicit Outcome Memory
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

Extensive OpenAPI-documented surface. 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.