OpenAI Integration

Change one line. Your GPT agent remembers everything.

If you're already using the OpenAI SDK, you're 30 seconds away from persistent memory. Hebbrix speaks the exact same API format. Swap your base URL, keep your code. Your agent now has a brain that doesn't wipe itself between conversations.

$pip install openai hebbrix

Get Started Chat API Docs

Spot the difference

Hint: it's two lines.

Before

without-memory.py

import openai

client = openai.OpenAI()

# Your agent talks to GPT-4
response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "user", "content": "What's my name?"}
    ]
)
# GPT: "I don't have access to your name."
# Every session starts from zero. Again.

After

with-hebbrix.py

import openai

# One line changes. That's it.
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's my name?"}
    ]
)
# GPT: "Your name is Alex. You mentioned it
# when we discussed your project last Tuesday."

What actually happens under the hood

When you point the OpenAI SDK at Hebbrix, a lot happens between your message and the model's response. All of it invisible to your code.

Your message arrives at Hebbrix

Same format as OpenAI. Same SDK. Same types. Your code doesn't know the difference.

Hebbrix searches for relevant memories

5-layer hybrid search: semantic vectors, BM25 keywords, knowledge graph traversal, importance scoring, recency boosting. All in under 50ms.

Relevant context is injected into the prompt

The model sees your message plus everything it needs to know about this user. Past conversations, preferences, related entities from the knowledge graph.

The request goes to GPT-4 (or whatever model you chose)

Hebbrix forwards your enriched request to the actual LLM. The response comes back with full context awareness.

The interaction becomes a memory

What was discussed gets stored. Entities get extracted. The knowledge graph grows. RL evaluates quality. Next time, the response will be even better.

Want more control? Use the SDK too.

The drop-in approach handles everything automatically. But sometimes you want to explicitly store something important, like a user preference your agent just learned, or search memories before deciding what to do.

Use both together. The OpenAI-compatible endpoint for automatic memory, and the Hebbrix SDK for explicit control when you need it.

explicit-memory.py

from hebbrix import Hebbrix

hebbrix = Hebbrix()

# Store something your agent learned
hebbrix.memories.create(
    content="Alex prefers Python, works at Acme Corp, "
            "building a customer support chatbot. "
            "Likes concise explanations with code examples."
)

# Next time Alex asks anything, Hebbrix
# automatically finds and injects this context
# before GPT-4 responds. No retrieval code needed.

Everything that comes along for the ride

3-tier memory

Short, medium, long-term. Just like a human brain.

5-layer search

Way beyond vector similarity. Five signals, one query.

Knowledge graph

Entities and relationships. Built automatically.

Self-improving

6 RL checks per interaction. Gets better on its own.

Natural decay

Old irrelevant memories fade. Context stays clean.

Zero migration

Same SDK, same types. Change the URL, keep the code.

Try it in 30 seconds

If you have OpenAI code running right now, you can add memory before your coffee gets cold.

Drop In Memory Full Guide