Coding Agent Integration

{
  "mcpServers": {
    "hebbrix": {
      "url": "https://mcp.hebbrix.com/mcp"
    }
  }
}

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 (adaptive 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, "wait_for_index": True},
        timeout=60,
    )
    r.raise_for_status()
    receipt = r.json()
    if receipt.get("searchable") is not True:
        return "Accepted, but indexing is still pending. Do not assume recall is ready."
    return "Stored and searchable."


@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},
    )
    r.raise_for_status()
    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"