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.
Pick the integration that fits your architecture
Both paths give you the full memory stack. The difference is where you want control.
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.
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())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.
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.
Every feature works on its own. No configuration.
You call two methods. Everything else is running in the background.
Current truth, superseded history, provenance, operational lifecycle tiers, retention controls, and explicit deletion.
Dense + sparse + graph + temporal + facet + calibrated ranking signals. One API call with confidence and fallback metadata.
Entity and relationship extraction on every memory you store. Zero schema to define. Query connections with mem.graph.search().
Record decision receipts and propensity, then report delayed outcomes. Inspect posterior evidence and uncertainty before changing behavior.
Collections isolate memory per user, per team, per project. One API, unlimited scopes. Maps cleanly to any data model you already have.
Old, irrelevant memories fade naturally. Context stays clean at production scale. Combine with explicit retention policies for compliance use cases.

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.

Start building in five minutes
Free tier, no credit card. 1,000 credits a month to build and evaluate. pip install and go.