Coding Agent Integration

# Install Hebbrix MCP Server
cd mcp
./quick_setup.sh

# Add to your Claude Desktop config
{
  "mcpServers": {
    "hebbrix": {
      "command": "python",
      "args": ["/path/to/hebbrix/mcp/server.py"],
      "env": {
        "HEBBRIX_API_KEY": "your_api_key"
      }
    }
  }
}

import asyncio
from hebbrix import MemoryClient

async def main():
    # The official Hebbrix Python SDK is async-first.
    async with MemoryClient(api_key="mem_sk_...") as client:
        collection = await client.collections.create(name="my_agent")

        # Store conversation context
        await client.memories.create(
            collection_id=collection["id"],
            content="User asked about API authentication",
            importance=0.7,
        )

        # Retrieve context for next response (6-layer hybrid search)
        results = await client.search(
            query="How do I authenticate?",
            collection_id=collection["id"],
            limit=5,
        )

        # Use results to enhance your agent's response
        context = "\n".join(r["content"] for r in results)
        # response = your_llm.generate(context + user_message)

asyncio.run(main())

import os
import requests
from langchain.tools import tool
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

HEBBRIX_API_KEY = os.environ["HEBBRIX_API_KEY"]
COLLECTION_ID = "my_agent"  # any collection you own
BASE = "https://api.hebbrix.com/v1"
H = {"Authorization": f"Bearer {HEBBRIX_API_KEY}"}


@tool
def remember(content: str) -> str:
    """Store a new memory for later retrieval."""
    r = requests.post(
        f"{BASE}/memories/raw",
        headers=H,
        json={"content": content, "collection_id": COLLECTION_ID},
    )
    r.raise_for_status()
    return "Stored."


@tool
def recall(query: str) -> str:
    """Search relevant memories for a query and return the top matches."""
    r = requests.post(
        f"{BASE}/search",
        headers=H,
        json={"query": query, "collection_id": COLLECTION_ID, "limit": 5},
    )
    hits = r.json().get("results", [])
    return "\n".join(f"- {h['content']}" for h in hits) or "(no memories)"


prompt = ChatPromptTemplate.from_messages([
    ("system", "You have tools to remember and recall long-term facts about the user."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])
llm = ChatOpenAI(model="gpt-4o-mini")
agent = create_openai_tools_agent(llm, [remember, recall], prompt)
executor = AgentExecutor(agent=agent, tools=[remember, recall], verbose=True)

# The agent can now persist and retrieve memories across runs
executor.invoke({"input": "Remember user preference: dark mode."})
executor.invoke({"input": "What UI theme does the user prefer?"})  # → "dark mode"